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/01/10 22:27:17 UTC
[5/8] geode git commit: Convert from ManagementTestCase to
ManagementTestRule
http://git-wip-us.apache.org/repos/asf/geode/blob/a409b5a2/geode-core/src/test/java/org/apache/geode/management/ManagementTestBase.java
----------------------------------------------------------------------
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 85d42ee..ef1c4fa 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
@@ -17,15 +17,17 @@ package org.apache.geode.management;
import static org.apache.geode.distributed.ConfigurationProperties.*;
import static org.junit.Assert.*;
+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.MBeanServer;
+
import javax.management.ObjectName;
-import org.apache.geode.LogWriter;
+import org.junit.Rule;
+
import org.apache.geode.cache.Cache;
import org.apache.geode.cache.CacheFactory;
import org.apache.geode.cache.Region;
@@ -35,39 +37,32 @@ 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.internal.statistics.SampleCollector;
import org.apache.geode.management.internal.FederatingManager;
import org.apache.geode.management.internal.LocalManager;
-import org.apache.geode.management.internal.MBeanJMXAdapter;
import org.apache.geode.management.internal.ManagementStrings;
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 JUnit4DistributedTestCase {
+public abstract class ManagementTestBase extends JUnit4CacheTestCase {
private static final int MAX_WAIT = 70 * 1000;
- /**
- * log writer instance
- */
- private static LogWriter logWriter;
-
- private static Properties props = new Properties();
-
- /**
- * Distributed System
- */
- protected static DistributedSystem ds;
+ // protected static DistributedSystem ds;
+ protected static ManagementService managementService;
+ // protected static Cache cache;
/**
* List containing all the Managed Node VM
@@ -79,23 +74,14 @@ public abstract class ManagementTestBase extends JUnit4DistributedTestCase {
*/
protected static VM managingNode;
- /**
- * Management Service
- */
- protected static ManagementService managementService;
-
protected static VM managedNode1;
protected static VM managedNode2;
protected static VM managedNode3;
protected static VM locatorVM;
- private static SampleCollector sampleCollector;
-
- protected static MBeanServer mbeanServer = MBeanJMXAdapter.mbeanServer;
-
- private static int mcastPort;
-
- protected static Cache cache;
+ @Rule
+ public DistributedRestoreSystemProperties restoreSystemProperties =
+ new DistributedRestoreSystemProperties();
@Override
public final void postSetUp() throws Exception {
@@ -119,16 +105,14 @@ public abstract class ManagementTestBase extends JUnit4DistributedTestCase {
protected void postSetUpManagementTestBase() throws Exception {}
@Override
- public final void preTearDown() throws Exception {
+ public final void preTearDownCacheTestCase() throws Exception {
preTearDownManagementTestBase();
- closeAllCache();
- managementService = null;
-
- mcastPort = 0;
- disconnectAllFromDS();
- props.clear();
+ }
+ @Override
+ public final void postTearDownCacheTestCase() throws Exception {
+ managementService = null;
postTearDownManagementTestBase();
}
@@ -136,99 +120,49 @@ public abstract class ManagementTestBase extends JUnit4DistributedTestCase {
protected void postTearDownManagementTestBase() throws Exception {}
- public void closeAllCache() throws Exception {
- closeCache(managingNode);
- closeCache(managedNode1);
- closeCache(managedNode2);
- closeCache(managedNode3);
- cache = null;
- }
-
- /**
- * Enable system property gemfire.disableManagement false in each VM.
- */
- public void enableManagement() {
- Invoke.invokeInEveryVM(new SerializableRunnable("Enable Management") {
- public void run() {
- System.setProperty(InternalDistributedSystem.DISABLE_MANAGEMENT_PROPERTY, "false");
- }
- });
-
- }
-
- /**
- * Disable system property gemfire.disableManagement true in each VM.
- */
- public void disableManagement() {
- Invoke.invokeInEveryVM(new SerializableRunnable("Disable Management") {
- public void run() {
- System.setProperty(InternalDistributedSystem.DISABLE_MANAGEMENT_PROPERTY, "true");
- }
- });
-
- }
-
/**
* managingNodeFirst variable tests for two different test cases where Managing & Managed Node
* creation time lines are reversed.
*/
- public void initManagement(boolean managingNodeFirst) throws Exception {
-
+ protected void initManagement(final boolean managingNodeFirst) throws Exception {
if (managingNodeFirst) {
createManagementCache(managingNode);
startManagingNode(managingNode);
-
for (VM vm : managedNodeList) {
createCache(vm);
-
}
} else {
for (VM vm : managedNodeList) {
createCache(vm);
-
}
createManagementCache(managingNode);
startManagingNode(managingNode);
}
}
- public void createCache(VM vm1) throws Exception {
- vm1.invoke(new SerializableRunnable("Create Cache") {
- public void run() {
- createCache(false);
- }
+ protected void createCache(final VM vm1) throws Exception {
+ vm1.invoke("Create Cache", () -> {
+ createCache(false);
});
-
}
- public void createCache(VM vm1, final Properties props) throws Exception {
- vm1.invoke(new SerializableRunnable("Create Cache") {
- public void run() {
- createCache(props);
- }
+ protected void createCache(final VM vm1, final Properties props) throws Exception {
+ vm1.invoke("Create Cache", () -> {
+ createCache(props);
});
-
}
- public Cache createCache(Properties props) {
- System.setProperty("dunitLogPerTest", "true");
- props.setProperty(LOG_FILE, getTestMethodName() + "-.log");
- ds = getSystem(props);
- cache = CacheFactory.create(ds);
+ private Cache createCache(final Properties props) {
+ Cache cache = getCache(props);
managementService = ManagementService.getManagementService(cache);
- logWriter = ds.getLogWriter();
- assertNotNull(cache);
- assertNotNull(managementService);
- return cache;
- }
- public Cache getCache() {
return cache;
}
- public Cache createCache(boolean management) {
- System.setProperty("dunitLogPerTest", "true");
+ protected Cache createCache(final boolean management) {
+
+ Properties props = new Properties();
if (management) {
props.setProperty(JMX_MANAGER, "true");
props.setProperty(JMX_MANAGER_START, "false");
@@ -238,68 +172,48 @@ public abstract class ManagementTestBase extends JUnit4DistributedTestCase {
props.setProperty(ENABLE_TIME_STATISTICS, "true");
props.setProperty(STATISTIC_SAMPLING_ENABLED, "true");
props.setProperty(LOG_FILE, getTestMethodName() + "-.log");
- ds = getSystem(props);
- cache = CacheFactory.create(ds);
+
+ Cache cache = getCache(props);
managementService = ManagementService.getManagementService(cache);
- logWriter = ds.getLogWriter();
- assertNotNull(cache);
- assertNotNull(managementService);
+
return cache;
}
- public void createManagementCache(VM vm1) throws Exception {
- vm1.invoke(new SerializableRunnable("Create Management Cache") {
- public void run() {
- createCache(true);
- }
+ protected void createManagementCache(final VM vm1) throws Exception {
+ vm1.invoke("Create Management Cache", () -> {
+ createCache(true);
});
}
- public void closeCache(VM vm1) throws Exception {
- vm1.invoke(new SerializableRunnable("Close Cache") {
- public void run() {
- GemFireCacheImpl existingInstance = GemFireCacheImpl.getInstance();
- if (existingInstance != null) {
- existingInstance.close();
- }
- InternalDistributedSystem ds = InternalDistributedSystem.getConnectedInstance();
- if (ds != null) {
- ds.disconnect();
- }
+ protected void closeCache(final VM vm1) throws Exception {
+ vm1.invoke("Close Cache", () -> {
+ GemFireCacheImpl existingInstance = GemFireCacheImpl.getInstance();
+ if (existingInstance != null) {
+ existingInstance.close();
+ }
+ InternalDistributedSystem ds = InternalDistributedSystem.getConnectedInstance();
+ if (ds != null) {
+ ds.disconnect();
}
});
-
- }
-
- public void closeCache() throws Exception {
- GemFireCacheImpl existingInstance = GemFireCacheImpl.getInstance();
- if (existingInstance != null) {
- existingInstance.close();
- }
- InternalDistributedSystem ds = InternalDistributedSystem.getConnectedInstance();
- if (ds != null) {
- ds.disconnect();
- }
}
- public String getMemberId(final VM vm) {
- SerializableCallable getMember = new SerializableCallable("getMemberId") {
- public Object call() throws Exception {
- GemFireCacheImpl cache = GemFireCacheImpl.getInstance();
- return cache.getDistributedSystem().getDistributedMember().getId();
- }
- };
- return (String) vm.invoke(getMember);
+ protected String getMemberId(final VM vm) {
+ return vm.invoke("getMemberId", () -> {
+ GemFireCacheImpl cache = GemFireCacheImpl.getInstance();
+ return cache.getDistributedSystem().getDistributedMember().getId();
+ });
}
protected static void waitForProxy(final ObjectName objectName, final Class interfaceClass) {
-
Wait.waitForCriterion(new WaitCriterion() {
+ @Override
public String description() {
return "Waiting for the proxy of " + objectName.getCanonicalName()
+ " to get propagated to Manager";
}
+ @Override
public boolean done() {
SystemManagementService service = (SystemManagementService) managementService;
if (service.getMBeanProxy(objectName, interfaceClass) != null) {
@@ -308,205 +222,55 @@ public abstract class ManagementTestBase extends JUnit4DistributedTestCase {
return false;
}
}
-
}, MAX_WAIT, 500, true);
}
- protected void runManagementTaskAdhoc() {
- SystemManagementService service = (SystemManagementService) managementService;
- service.getLocalManager().runManagementTaskAdhoc();
- }
-
/**
* Marks a VM as Managing
- *
- * @throws Exception
*/
- public void startManagingNode(VM vm1) throws Exception {
- vm1.invoke(new SerializableRunnable("Start Being Managing Node") {
- public void run() {
- startBeingManagingNode();
- }
- });
-
- }
-
- public void startBeingManagingNode() {
- Cache existingCache = GemFireCacheImpl.getInstance();
- if (existingCache != null && !existingCache.isClosed()) {
+ protected void startManagingNode(final VM vm1) {
+ vm1.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();
- }
- }
-
- /**
- * Marks a VM as Managing
- *
- * @throws Exception
- */
- public void startManagingNodeAsync(VM vm1) throws Exception {
- vm1.invokeAsync(new SerializableRunnable("Start Being Managing Node") {
-
- public void run() {
- Cache existingCache = GemFireCacheImpl.getInstance();
- if (existingCache != null && !existingCache.isClosed()) {
- managementService = ManagementService.getManagementService(existingCache);
- managementService.startManager();
- }
-
- }
+ // }
});
-
}
/**
* Stops a VM as a Managing node
- *
- * @throws Exception
- */
- public void stopManagingNode(VM vm1) throws Exception {
- vm1.invoke(new SerializableRunnable("Stop Being Managing Node") {
- public void run() {
- Cache existingCache = GemFireCacheImpl.getInstance();
- if (existingCache != null && !existingCache.isClosed()) {
- if (managementService.isManager()) {
- managementService.stopManager();
- }
-
- }
-
- }
- });
-
- }
-
- /**
- * Check various resources clean up Once a VM stops being managable it should remove all the
- * artifacts of management namely a) Notification region b) Monitoring Region c) Management task
- * should stop
- */
- public void checkManagedNodeCleanup(VM vm) throws Exception {
- vm.invoke(new SerializableRunnable("Managing Node Clean up") {
-
- public void run() {
- Cache existingCache = GemFireCacheImpl.getInstance();
- if (existingCache != null) {
- // Cache is closed
- assertEquals(true, existingCache.isClosed());
- // ManagementService should throw exception
- LocalManager localManager =
- ((SystemManagementService) managementService).getLocalManager();
- // Check Monitoring region destroyed
- Region monitoringRegion =
- localManager.getManagementResourceRepo().getLocalMonitoringRegion();
- assertEquals(null, monitoringRegion);
- // check Notification region is destroyed
- Region notifRegion =
- localManager.getManagementResourceRepo().getLocalNotificationRegion();
- assertEquals(null, notifRegion);
- // check ManagementTask is stopped
- assertEquals(true, localManager.getFederationSheduler().isShutdown());
-
- }
-
- }
- });
-
- }
-
- /**
- * Check various resources clean up Once a VM stops being Managing.It should remove all the
- * artifacts of management namely a) proxies b) Monitoring Region c) Management task should stop
*/
-
- public void checkProxyCleanup(VM vm) throws Exception {
-
- vm.invoke(new SerializableRunnable("Managing Node Clean up") {
-
- public void run() {
-
- try {
- GemFireCacheImpl existingCache = GemFireCacheImpl.getInstance();
- if (existingCache == null) {
- return;
- }
-
- assertEquals(false, existingCache.isClosed());
- // ManagementService should not be closed
-
- Set<DistributedMember> otherMemberSet =
- existingCache.getDistributionManager().getOtherDistributionManagerIds();
-
- Iterator<DistributedMember> it = otherMemberSet.iterator();
- FederatingManager federatingManager =
- ((SystemManagementService) managementService).getFederatingManager();
-
- // check Proxy factory. There should not be any proxies left
- DistributedMember member;
- while (it.hasNext()) {
- member = it.next();
-
- assertNull(federatingManager.getProxyFactory().findAllProxies(member));
- }
-
- } catch (ManagementException e) {
- Assert.fail("failed with ManagementException", e);
+ protected void stopManagingNode(final VM vm1) {
+ vm1.invoke("Stop Being Managing Node", () -> {
+ Cache existingCache = GemFireCacheImpl.getInstance();
+ if (existingCache != null && !existingCache.isClosed()) {
+ if (managementService.isManager()) {
+ managementService.stopManager();
}
}
});
-
- }
-
- /**
- * All the expected exceptions are checked here
- *
- * @param e
- * @return is failed
- */
- public boolean checkManagementExceptions(ManagementException e) {
-
- if (e.getMessage().equals(ManagementStrings.Management_Service_CLOSED_CACHE)
- || e.getMessage().equals(
- ManagementStrings.Management_Service_MANAGEMENT_SERVICE_IS_CLOSED.toLocalizedString())
- || e.getMessage()
- .equals(ManagementStrings.Management_Service_MANAGEMENT_SERVICE_NOT_STARTED_YET
- .toLocalizedString())
- || e.getMessage().equals(
- ManagementStrings.Management_Service_NOT_A_GEMFIRE_DOMAIN_MBEAN.toLocalizedString())
- || e.getMessage().equals(
- ManagementStrings.Management_Service_NOT_A_MANAGING_NODE_YET.toLocalizedString())
- || e.getMessage()
- .equals(ManagementStrings.Management_Service_OPERATION_NOT_ALLOWED_FOR_CLIENT_CACHE
- .toLocalizedString())
- || e.getMessage()
- .equals(ManagementStrings.Management_Service_PROXY_NOT_AVAILABLE.toLocalizedString())) {
-
- return false;
- }
- return true;
}
- public static List<VM> getManagedNodeList() {
+ protected static List<VM> getManagedNodeList() {
return managedNodeList;
}
- public static VM getManagingNode() {
+ protected static VM getManagingNode() {
return managingNode;
}
- public static ManagementService getManagementService() {
+ protected static ManagementService getManagementService() {
return managementService;
}
/**
* Creates a Distributed region
- *
- * @param vm reference to VM
- * @param regionName name of the distributed region
*/
- protected void createDistributedRegion(VM vm, final String regionName) throws Exception {
+ protected void createDistributedRegion(final VM vm, final String regionName)
+ throws InterruptedException {
AsyncInvocation future = createDistributedRegionAsync(vm, regionName);
future.join(MAX_WAIT);
if (future.isAlive()) {
@@ -519,169 +283,103 @@ public abstract class ManagementTestBase extends JUnit4DistributedTestCase {
/**
* Creates a Local region
- *
- * @param vm reference to VM
- * @param localRegionName name of the local region
*/
- protected void createLocalRegion(VM vm, final String localRegionName) throws Exception {
- SerializableRunnable createLocalRegion = new SerializableRunnable("Create Local region") {
- public void run() {
- GemFireCacheImpl cache = GemFireCacheImpl.getInstance();
- SystemManagementService service = (SystemManagementService) getManagementService();
- RegionFactory rf = cache.createRegionFactory(RegionShortcut.LOCAL);
-
- org.apache.geode.test.dunit.LogWriterUtils.getLogWriter().info("Creating Local Region");
- rf.create(localRegionName);
-
- }
- };
- vm.invoke(createLocalRegion);
+ protected void createLocalRegion(final VM vm, final String localRegionName) throws Exception {
+ 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
- *
- * @param vm reference to VM
*/
- protected void createSubRegion(VM vm, final String parentRegionPath, final String subregionName)
- throws Exception {
- SerializableRunnable createSubRegion = new SerializableRunnable("Create Sub region") {
- public void run() {
- GemFireCacheImpl cache = GemFireCacheImpl.getInstance();
- SystemManagementService service = (SystemManagementService) getManagementService();
- Region region = cache.getRegion(parentRegionPath);
-
- org.apache.geode.test.dunit.LogWriterUtils.getLogWriter().info("Creating Sub Region");
- region.createSubregion(subregionName, region.getAttributes());
-
- }
- };
- vm.invoke(createSubRegion);
- }
-
- /**
- * Puts in distributed region
- *
- * @param vm
- */
- protected void putInDistributedRegion(final VM vm, final String key, final String value,
- final String regionPath) {
- SerializableRunnable put = new SerializableRunnable("Put In Distributed Region") {
- public void run() {
-
- GemFireCacheImpl cache = GemFireCacheImpl.getInstance();
- Region region = cache.getRegion(regionPath);
- region.put(key, value);
-
- }
- };
- vm.invoke(put);
+ protected void createSubRegion(final VM vm, final String parentRegionPath,
+ final String subregionName) throws Exception {
+ vm.invoke("Create Sub region", () -> {
+ GemFireCacheImpl 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
- *
- * @param vm
*/
- protected AsyncInvocation createDistributedRegionAsync(final VM vm, final String regionName) {
- SerializableRunnable createRegion = new SerializableRunnable("Create Distributed region") {
- public void run() {
-
- GemFireCacheImpl cache = GemFireCacheImpl.getInstance();
- SystemManagementService service = (SystemManagementService) getManagementService();
-
- RegionFactory rf = cache.createRegionFactory(RegionShortcut.REPLICATE);
- org.apache.geode.test.dunit.LogWriterUtils.getLogWriter().info("Creating Dist Region");
- rf.create(regionName);
-
- }
- };
- return vm.invokeAsync(createRegion);
+ 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);
+ });
}
/**
* Creates a partition Region
- *
- * @param vm
*/
protected void createPartitionRegion(final VM vm, final String partitionRegionName) {
- SerializableRunnable createParRegion = new SerializableRunnable("Create Partitioned region") {
- public void run() {
- GemFireCacheImpl cache = GemFireCacheImpl.getInstance();
- SystemManagementService service = (SystemManagementService) getManagementService();
- RegionFactory rf = cache.createRegionFactory(RegionShortcut.PARTITION_REDUNDANT);
- org.apache.geode.test.dunit.LogWriterUtils.getLogWriter().info("Creating Par Region");
- rf.create(partitionRegionName);
-
- }
- };
- vm.invoke(createParRegion);
- }
-
- /**
- * closes a Distributed Region
- *
- * @param vm
- */
- protected void closeRegion(final VM vm, final String regionPath) {
- SerializableRunnable closeRegion = new SerializableRunnable("Close Distributed region") {
- public void run() {
- GemFireCacheImpl cache = GemFireCacheImpl.getInstance();
-
- org.apache.geode.test.dunit.LogWriterUtils.getLogWriter().info("Closing Dist Region");
- Region region = cache.getRegion(regionPath);
- region.close();
-
- }
- };
- vm.invoke(closeRegion);
+ vm.invoke("Create Partitioned region", () -> {
+ GemFireCacheImpl cache = GemFireCacheImpl.getInstance();
+ SystemManagementService service = (SystemManagementService) getManagementService();
+ RegionFactory rf = cache.createRegionFactory(RegionShortcut.PARTITION_REDUNDANT);
+ LogWriterUtils.getLogWriter().info("Creating Par Region");
+ rf.create(partitionRegionName);
+ });
}
- public void waitForAllMembers(final int expectedCount) {
+ 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) {
-
- org.apache.geode.test.dunit.LogWriterUtils.getLogWriter()
+ 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());
}
- public static void waitForRefresh(final int expectedRefreshCount, final ObjectName objectName) {
+ protected static void waitForRefresh(final int expectedRefreshCount,
+ final ObjectName objectName) {
final ManagementService service = getManagementService();
- final long currentTime = System.currentTimeMillis();
-
Wait.waitForCriterion(new WaitCriterion() {
- int actualRefreshCount = 0;
- long lastRefreshTime = service.getLastUpdateTime(objectName);
+ private int actualRefreshCount = 0;
+ private long lastRefreshTime = service.getLastUpdateTime(objectName);
+ @Override
public String description() {
return "Waiting For Proxy Refresh Count = " + expectedRefreshCount;
}
+ @Override
public boolean done() {
long newRefreshTime = service.getLastUpdateTime(objectName);
if (newRefreshTime > lastRefreshTime) {
@@ -694,12 +392,10 @@ public abstract class ManagementTestBase extends JUnit4DistributedTestCase {
}
return false;
}
-
}, MAX_WAIT, 500, true);
-
}
- public DistributedMember getMember(final VM vm) {
+ protected DistributedMember getMember(final VM vm) {
SerializableCallable getMember = new SerializableCallable("Get Member") {
public Object call() {
GemFireCacheImpl cache = GemFireCacheImpl.getInstance();
@@ -709,4 +405,14 @@ public abstract class ManagementTestBase extends JUnit4DistributedTestCase {
};
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) {
+ SystemManagementService service =
+ (SystemManagementService) ManagementService.getManagementService(getCache());
+ return service.getMBeanProxy(objectName, interfaceClass);
+ }
}
http://git-wip-us.apache.org/repos/asf/geode/blob/a409b5a2/geode-core/src/test/java/org/apache/geode/management/ManagementTestRule.java
----------------------------------------------------------------------
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
new file mode 100644
index 0000000..e97a652
--- /dev/null
+++ b/geode-core/src/test/java/org/apache/geode/management/ManagementTestRule.java
@@ -0,0 +1,437 @@
+/*
+ * 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 org.apache.geode.distributed.ConfigurationProperties.*;
+import static org.apache.geode.test.dunit.Host.*;
+import static org.assertj.core.api.Assertions.*;
+
+import java.io.Serializable;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Field;
+import java.util.HashSet;
+import java.util.Properties;
+import java.util.Set;
+
+import org.junit.rules.MethodRule;
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.Statement;
+
+import org.apache.geode.cache.Cache;
+import org.apache.geode.cache.client.ClientCache;
+import org.apache.geode.cache.client.ClientCacheFactory;
+import org.apache.geode.distributed.DistributedMember;
+import org.apache.geode.distributed.DistributedSystemDisconnectedException;
+import org.apache.geode.distributed.internal.DM;
+import org.apache.geode.distributed.internal.DistributionManager;
+import org.apache.geode.internal.cache.GemFireCacheImpl;
+import org.apache.geode.management.internal.SystemManagementService;
+import org.apache.geode.test.dunit.Invoke;
+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;
+
+/**
+ * Overriding MethodRule is only way to get {@code Object target}
+ */
+@SuppressWarnings("unused")
+public class ManagementTestRule implements MethodRule, Serializable {
+
+ public static Builder builder() {
+ return new Builder();
+ }
+
+ private final int managersCount;
+ private final int membersCount;
+ private final boolean start;
+ private final boolean managersFirst;
+ private final boolean createManagers;
+ private final boolean createMembers;
+
+ private JUnit4CacheTestCase helper;
+
+ private VM[] managers;
+ private VM[] members;
+
+ protected ManagementTestRule(final Builder builder) {
+ this.helper = new JUnit4CacheTestCase() {};
+ this.managersCount = builder.managersCount;
+ this.membersCount = builder.membersCount;
+ this.start = builder.start;
+ this.managersFirst = builder.managersFirst;
+ this.createManagers = builder.createManagers;
+ this.createMembers = builder.createMembers;
+ }
+
+ public DistributedMember getDistributedMember() {
+ return getCache().getDistributedSystem().getDistributedMember();
+ }
+
+ public DistributedMember getDistributedMember(final VM vm) {
+ return vm.invoke("getDistributedMember", () -> getDistributedMember());
+ }
+
+ public void createManagers() {
+ for (VM manager : this.managers) {
+ manager.invoke(() -> createManager(true));
+ }
+ }
+
+ public void createMembers() {
+ for (VM member : this.members) {
+ member.invoke(() -> createMember());
+ }
+ }
+
+ public void createManager() {
+ createManager(true);
+ }
+
+ public void createManager(final Properties properties) {
+ createManager(properties, true);
+ }
+
+ public void createManager(final boolean start) {
+ createManager(new Properties(), start);
+ }
+
+ public void createManager(final Properties properties, final boolean start) {
+ setPropertyIfNotSet(properties, JMX_MANAGER, "true");
+ setPropertyIfNotSet(properties, JMX_MANAGER_START, "false");
+ setPropertyIfNotSet(properties, JMX_MANAGER_PORT, "0");
+ setPropertyIfNotSet(properties, HTTP_SERVICE_PORT, "0");
+ setPropertyIfNotSet(properties, ENABLE_TIME_STATISTICS, "true");
+ setPropertyIfNotSet(properties, STATISTIC_SAMPLING_ENABLED, "true");
+
+ this.helper.getCache(properties);
+
+ if (start) {
+ startManager();
+ }
+ }
+
+ public void createManager(final VM managerVM) {
+ managerVM.invoke("createManager", () -> createManager());
+ }
+
+ public void createManager(final VM managerVM, final boolean start) {
+ managerVM.invoke("createManager", () -> createManager(start));
+ }
+
+ public void createManager(final VM managerVM, final Properties properties) {
+ managerVM.invoke("createManager", () -> createManager(properties, true));
+ }
+
+ public void createManager(final VM managerVM, final Properties properties, final boolean start) {
+ managerVM.invoke("createManager", () -> createManager(properties, start));
+ }
+
+ public void createMember() {
+ createMember(new Properties());
+ }
+
+ public void createMember(final Properties properties) {
+ setPropertyIfNotSet(properties, JMX_MANAGER, "false");
+ setPropertyIfNotSet(properties, ENABLE_TIME_STATISTICS, "true");
+ setPropertyIfNotSet(properties, STATISTIC_SAMPLING_ENABLED, "true");
+
+ System.out.println("KIRK: creating " + properties.getProperty(NAME));
+ this.helper.getCache(properties);
+ }
+
+ public void createMember(final VM memberVM) {
+ Properties properties = new Properties();
+ properties.setProperty(NAME, "memberVM-" + memberVM.getPid());
+ memberVM.invoke("createMember", () -> createMember(properties));
+ }
+
+ public void createMember(final VM memberVM, final Properties properties) throws Exception {
+ memberVM.invoke("createMember", () -> createMember(properties));
+ }
+
+ public Cache getCache() {
+ // Cache cache = GemFireCacheImpl.getInstance();
+ // if (cache != null && !cache.isClosed()) {
+ // return cache;
+ // }
+ return this.helper.getCache();
+ }
+
+ public ClientCache getClientCache() {
+ return this.helper.getClientCache(new ClientCacheFactory());
+ }
+
+ public boolean hasCache() {
+ // Cache cache = GemFireCacheImpl.getInstance();
+ // if (cache != null && !cache.isClosed()) {
+ // return true;
+ // }
+ return this.helper.hasCache();
+ }
+
+ public Cache basicGetCache() {
+ // Cache cache = GemFireCacheImpl.getInstance();
+ // if (cache != null && !cache.isClosed()) {
+ // return cache;
+ // }
+ return this.helper.basicGetCache();
+ }
+
+ public ManagementService getManagementService() {
+ assertThat(hasCache()).isTrue();
+ return ManagementService.getManagementService(basicGetCache());
+ }
+
+ public SystemManagementService getSystemManagementService() {
+ assertThat(hasCache()).isTrue();
+ return (SystemManagementService) ManagementService.getManagementService(basicGetCache());
+ }
+
+ public ManagementService getExistingManagementService() {
+ assertThat(hasCache()).isTrue();
+ return ManagementService.getExistingManagementService(basicGetCache());
+ }
+
+ public void startManager() {
+ SystemManagementService service = getSystemManagementService();
+ service.createManager();
+ service.startManager();
+ }
+
+ public void startManager(final VM managerVM) {
+ managerVM.invoke("startManager", () -> startManager());
+ }
+
+ public void stopManager() {
+ if (getManagementService().isManager()) {
+ getManagementService().stopManager();
+ }
+ }
+
+ public void stopManager(final VM managerVM) {
+ managerVM.invoke("stopManager", () -> stopManager());
+ }
+
+ public Set<DistributedMember> getOtherNormalMembers() {
+ Set<DistributedMember> allMembers = new HashSet<>(getAllNormalMembers());
+ allMembers.remove(getDistributedMember());
+ return allMembers;
+ }
+
+ public Set<DistributedMember> getAllNormalMembers() {
+ return getDistributionManager().getNormalDistributionManagerIds(); // excludes LOCATOR_DM_TYPE
+ }
+
+ private DM getDistributionManager() {
+ return ((GemFireCacheImpl) getCache()).getDistributionManager();
+ }
+
+ public void disconnectAllFromDS() {
+ stopManagerQuietly();
+ Invoke.invokeInEveryVM("stopManager", () -> stopManagerQuietly());
+ JUnit4DistributedTestCase.disconnectFromDS();
+ Invoke.invokeInEveryVM("disconnectFromDS", () -> JUnit4DistributedTestCase.disconnectFromDS());
+ }
+
+ private void setPropertyIfNotSet(final Properties properties, final String key,
+ final String value) {
+ if (!properties.containsKey(key)) {
+ properties.setProperty(key, value);
+ }
+ }
+
+ private void stopManagerQuietly() {
+ try {
+ if (hasCache() && !basicGetCache().isClosed()) {
+ stopManager();
+ }
+ } catch (DistributedSystemDisconnectedException | NullPointerException ignore) {
+ }
+ }
+
+ @Override
+ public Statement apply(final Statement base, final FrameworkMethod method, final Object target) {
+ return new Statement() {
+ @Override
+ public void evaluate() throws Throwable {
+ setUp(target);
+ try {
+ base.evaluate();
+ } finally {
+ tearDown();
+ }
+ }
+ };
+ }
+
+ private void setUp(final Object target) throws Exception {
+ DUnitLauncher.launchIfNeeded();
+ JUnit4DistributedTestCase.disconnectAllFromDS();
+
+ int whichVM = 0;
+
+ this.managers = new VM[this.managersCount];
+ for (int i = 0; i < this.managersCount; i++) {
+ this.managers[i] = getHost(0).getVM(whichVM);
+ whichVM++;
+ }
+
+ this.members = new VM[this.membersCount];
+ for (int i = 0; i < this.membersCount; i++) {
+ this.members[i] = getHost(0).getVM(whichVM);
+ whichVM++;
+ }
+
+ if (this.start) {
+ start();
+ }
+
+ processAnnotations(target);
+ }
+
+ private void start() {
+ if (this.createManagers && this.managersFirst) {
+ createManagers();
+ }
+ if (this.createMembers) {
+ createMembers();
+ }
+ if (this.createManagers && !this.managersFirst) {
+ createManagers();
+ }
+ }
+
+ private void tearDown() throws Exception {
+ JUnit4DistributedTestCase.disconnectAllFromDS();
+ }
+
+ private void processAnnotations(final Object target) {
+ try {
+ Class<?> clazz = target.getClass();
+
+ Field[] fields = clazz.getDeclaredFields();
+ for (Field field : fields) {
+ boolean alreadyAssigned = false;
+ for (Annotation annotation : field.getAnnotations()) {
+ if (annotation.annotationType().equals(Manager.class)) {
+ // annotated with @Manager
+ throwIfAlreadyAssigned(field, alreadyAssigned);
+ assignManagerField(target, field);
+ alreadyAssigned = true;
+ }
+ if (annotation.annotationType().equals(Member.class)) {
+ // annotated with @Manager
+ throwIfAlreadyAssigned(field, alreadyAssigned);
+ assignMemberField(target, field);
+ alreadyAssigned = true;
+ }
+ }
+ }
+ } catch (IllegalAccessException e) {
+ throw new Error(e);
+ }
+ }
+
+ private void throwIfAlreadyAssigned(final Field field, final boolean alreadyAssigned) {
+ if (alreadyAssigned) {
+ throw new IllegalStateException(
+ "Field " + field.getName() + " is already annotated with " + field.getAnnotations());
+ }
+ }
+
+ private void assignManagerField(final Object target, final Field field)
+ throws IllegalAccessException {
+ throwIfNotSameType(field, VM.class);
+
+ field.setAccessible(true);
+ if (field.getType().isArray()) {
+ field.set(target, this.managers);
+ } else {
+ field.set(target, this.managers[0]);
+ }
+ }
+
+ private void assignMemberField(final Object target, final Field field)
+ throws IllegalAccessException {
+ throwIfNotSameType(field, VM.class);
+
+ field.setAccessible(true);
+ if (field.getType().isArray()) {
+ field.set(target, this.members);
+ } else {
+ field.set(target, this.members[0]);
+ }
+ }
+
+ private void throwIfNotSameType(final Field field, final Class clazz) {
+ if (!field.getType().equals(clazz) && // non-array
+ !field.getType().getComponentType().equals(clazz)) { // array
+ throw new IllegalArgumentException(
+ "Field " + field.getName() + " is not same type as " + clazz.getName());
+ }
+ }
+
+ public static class Builder {
+
+ private boolean start = false;
+
+ private boolean createManagers = true;
+
+ private boolean createMembers = true;
+
+ private int managersCount = 1;
+
+ private int membersCount = 3;
+
+ private boolean managersFirst = true;
+
+ protected Builder() {}
+
+ public Builder createManagers(final boolean value) {
+ this.createManagers = value;
+ return this;
+ }
+
+ public Builder createMembers(final boolean value) {
+ this.createMembers = value;
+ return this;
+ }
+
+ public Builder withManagers(final int count) {
+ this.managersCount = count;
+ return this;
+ }
+
+ public Builder withMembers(final int count) {
+ this.membersCount = count;
+ return this;
+ }
+
+ public Builder managersFirst(final boolean value) {
+ this.managersFirst = value;
+ return this;
+ }
+
+ public Builder start(final boolean value) {
+ this.start = value;
+ return this;
+ }
+
+ public ManagementTestRule build() {
+ return new ManagementTestRule(this);
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/geode/blob/a409b5a2/geode-core/src/test/java/org/apache/geode/management/Manager.java
----------------------------------------------------------------------
diff --git a/geode-core/src/test/java/org/apache/geode/management/Manager.java b/geode-core/src/test/java/org/apache/geode/management/Manager.java
new file mode 100644
index 0000000..ce6c6a6
--- /dev/null
+++ b/geode-core/src/test/java/org/apache/geode/management/Manager.java
@@ -0,0 +1,29 @@
+/*
+ * 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.annotation.ElementType.FIELD;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+@Target(FIELD)
+@Retention(RUNTIME)
+@Documented
+public @interface Manager {
+ String name() default "";
+}
http://git-wip-us.apache.org/repos/asf/geode/blob/a409b5a2/geode-core/src/test/java/org/apache/geode/management/Member.java
----------------------------------------------------------------------
diff --git a/geode-core/src/test/java/org/apache/geode/management/Member.java b/geode-core/src/test/java/org/apache/geode/management/Member.java
new file mode 100644
index 0000000..84a80e5
--- /dev/null
+++ b/geode-core/src/test/java/org/apache/geode/management/Member.java
@@ -0,0 +1,29 @@
+/*
+ * 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.annotation.ElementType.FIELD;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+@Target(FIELD)
+@Retention(RUNTIME)
+@Documented
+public @interface Member {
+ String name() default "";
+}
http://git-wip-us.apache.org/repos/asf/geode/blob/a409b5a2/geode-core/src/test/java/org/apache/geode/management/OffHeapManagementDUnitTest.java
----------------------------------------------------------------------
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 289d6d7..97fdab1 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,6 +14,7 @@
*/
package org.apache.geode.management;
+import static com.jayway.awaitility.Awaitility.*;
import static org.apache.geode.distributed.ConfigurationProperties.*;
import static org.junit.Assert.*;
@@ -21,8 +22,11 @@ import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Properties;
+import java.util.concurrent.TimeUnit;
+
import javax.management.Attribute;
import javax.management.AttributeList;
+import javax.management.JMException;
import javax.management.MBeanServer;
import javax.management.Notification;
import javax.management.NotificationListener;
@@ -36,31 +40,27 @@ import org.apache.geode.cache.Cache;
import org.apache.geode.cache.DataPolicy;
import org.apache.geode.cache.Region;
import org.apache.geode.distributed.internal.InternalDistributedSystem;
-import org.apache.geode.internal.cache.GemFireCacheImpl;
-import org.apache.geode.internal.offheap.OffHeapMemoryStats;
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.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.junit.categories.DistributedTest;
/**
* Tests the off-heap additions to the RegionMXBean and MemberMXBean JMX interfaces.
*/
-@SuppressWarnings("serial")
@Category(DistributedTest.class)
+@SuppressWarnings("serial")
public class OffHeapManagementDUnitTest extends JUnit4CacheTestCase {
+
/**
* Specified assertion operations.
*/
- private static enum ASSERT_OP {
+ private enum ASSERT_OP {
EQUAL, GREATER_THAN, GREATER_THAN_OR_EQUAL, LESS_THAN
}
@@ -139,28 +139,20 @@ public class OffHeapManagementDUnitTest extends JUnit4CacheTestCase {
@Override
public final void postSetUp() throws Exception {
- Host.getHost(0).getVM(0).invoke(new SerializableRunnable() {
- @Override
- public void run() {
- System.setProperty(OffHeapStorage.STAY_CONNECTED_ON_OUTOFOFFHEAPMEMORY_PROPERTY, "true");
- }
+ Host.getHost(0).getVM(0).invoke(() -> {
+ System.setProperty(OffHeapStorage.STAY_CONNECTED_ON_OUTOFOFFHEAPMEMORY_PROPERTY, "true");
});
}
@Override
public final void preTearDownCacheTestCase() throws Exception {
- Host.getHost(0).getVM(0).invoke(new SerializableRunnable() {
- @Override
- public void run() {
- System.clearProperty(OffHeapStorage.STAY_CONNECTED_ON_OUTOFOFFHEAPMEMORY_PROPERTY);
- }
+ Host.getHost(0).getVM(0).invoke(() -> {
+ System.clearProperty(OffHeapStorage.STAY_CONNECTED_ON_OUTOFOFFHEAPMEMORY_PROPERTY);
});
}
/**
* Tests off-heap additions to the RegionMXBean and MemberMXBean interfaces.
- *
- * @throws Exception
*/
@Test
public void testOffHeapMBeanAttributesAndStats() throws Exception {
@@ -209,8 +201,6 @@ public class OffHeapManagementDUnitTest extends JUnit4CacheTestCase {
/**
* Tests the fragmentation statistic for off-heap memory.
- *
- * @throws Exception
*/
@Test
public void testFragmentationStat() throws Exception {
@@ -300,9 +290,7 @@ public class OffHeapManagementDUnitTest extends JUnit4CacheTestCase {
}
/**
- * Tests the compation time statistic for off-heap memory.
- *
- * @throws Exception
+ * Tests the compaction time statistic for off-heap memory.
*/
@Test
public void testCompactionTimeStat() throws Exception {
@@ -476,12 +464,13 @@ public class OffHeapManagementDUnitTest extends JUnit4CacheTestCase {
/**
* Destroys a number of entries previously allocated.
- *
+ *
* @param vm a virtual machine
* @param numAllocations the number of previous off-heap allocations
* @param numDestroys the number of destroys to perform
*/
- protected void doFreeOffHeapMemoryOnVm(VM vm, final int numAllocations, final int numDestroys) {
+ private void doFreeOffHeapMemoryOnVm(final VM vm, final int numAllocations,
+ final int numDestroys) {
vm.invoke(new SerializableRunnable() {
@Override
public void run() {
@@ -492,11 +481,11 @@ public class OffHeapManagementDUnitTest extends JUnit4CacheTestCase {
/**
* Performs some destroys to free off-heap allocations.
- *
+ *
* @param numAllocations the number of previous off-heap allocations
* @param numDestroys the number of destroys to perform
*/
- protected void doFreeOffHeapMemory(int numAllocations, int numDestroys) {
+ private void doFreeOffHeapMemory(final int numAllocations, final int numDestroys) {
assertTrue(numDestroys <= numAllocations);
Region region = getCache().getRegion(OFF_HEAP_REGION_NAME);
@@ -520,34 +509,29 @@ public class OffHeapManagementDUnitTest extends JUnit4CacheTestCase {
/**
* Consumes off off-heap memory until the allocation size cannot be satisfied.
- *
+ *
* @param vm a virtual machine
* @param allocationSize the number of bytes for each allocation
+ *
* @return the number of successful puts
*/
- protected int doConsumeOffHeapMemoryOnVm(VM vm, final int allocationSize) {
- return (Integer) vm.invoke(new SerializableCallable() {
- @Override
- public Object call() {
- return doConsumeOffHeapMemory(allocationSize);
- }
- });
+ private int doConsumeOffHeapMemoryOnVm(final VM vm, final int allocationSize) {
+ return vm.invoke(() -> doConsumeOffHeapMemory(allocationSize));
}
/**
* Consumes off off-heap memory until the allocation size cannot be satisfied.
- *
+ *
* @param allocationSize the number of bytes for each allocation
+ *
* @return the number of successful puts
*/
- protected int doConsumeOffHeapMemory(int allocationSize) { // TODO:KIRK: change this to handle new
- // OutOfOffHeapMemoryException
- OffHeapMemoryStats stats = ((GemFireCacheImpl) getCache()).getOffHeapStore().getStats();
+ private int doConsumeOffHeapMemory(final int allocationSize) {
int i = 0;
// Loop until we fail
try {
- while (true) {
+ while (true) { // TODO: put a time limit on this just in case
doPut("KEY" + (i++), new byte[allocationSize], OFF_HEAP_REGION_NAME, false);
}
} catch (OutOfOffHeapMemoryException e) {
@@ -558,28 +542,23 @@ public class OffHeapManagementDUnitTest extends JUnit4CacheTestCase {
/**
* Asserts that the compactionTime stat is available and satisfies an assert operation.
- *
+ *
* @param vm a virtual machine.
* @param compactionTime total off heap compaction time.
* @param op an assert operation.
*/
- protected void assertCompactionTimeStatOnVm(VM vm, final long compactionTime,
+ private void assertCompactionTimeStatOnVm(final VM vm, final long compactionTime,
final ASSERT_OP op) {
- vm.invoke(new SerializableRunnable() {
- @Override
- public void run() {
- assertCompactionTimeStat(compactionTime, op);
- }
- });
+ vm.invoke(() -> assertCompactionTimeStat(compactionTime, op));
}
/**
* Asserts that the compactionTime stat is available and satisfies an assert operation.
- *
+ *
* @param compactionTime total off heap compaction time.
* @param op an assert operation.
*/
- protected void assertCompactionTimeStat(long compactionTime, ASSERT_OP op) {
+ private void assertCompactionTimeStat(final long compactionTime, final ASSERT_OP op) {
ManagementService service = ManagementService.getExistingManagementService(getCache());
assertNotNull(service);
@@ -606,27 +585,23 @@ public class OffHeapManagementDUnitTest extends JUnit4CacheTestCase {
/**
* Asserts that the fragmentation stat is available and satisfies an assert operation.
- *
+ *
* @param vm a virtual machine
* @param fragmentation a fragmentation percentage
* @param op an assertion operation
*/
- protected void assertFragmentationStatOnVm(VM vm, final int fragmentation, final ASSERT_OP op) {
- vm.invoke(new SerializableRunnable() {
- @Override
- public void run() {
- assertFragmentationStat(fragmentation, op);
- }
- });
+ private void assertFragmentationStatOnVm(final VM vm, final int fragmentation,
+ final ASSERT_OP op) {
+ vm.invoke(() -> assertFragmentationStat(fragmentation, op));
}
/**
* Asserts that the fragmentation stat is available and satisfies an assert operation.
- *
+ *
* @param fragmentation a fragmentation percentage
* @param op an assertion operation
*/
- protected void assertFragmentationStat(int fragmentation, ASSERT_OP op) {
+ private void assertFragmentationStat(final int fragmentation, final ASSERT_OP op) {
ManagementService service = ManagementService.getExistingManagementService(getCache());
assertNotNull(service);
@@ -651,7 +626,7 @@ public class OffHeapManagementDUnitTest extends JUnit4CacheTestCase {
/**
* Returns off-heap system properties for enabling off-heap and the JMX system.
*/
- protected Properties getSystemProperties() {
+ private Properties getSystemProperties() {
Properties props = getDistributedSystemProperties();
props.setProperty(OFF_HEAP_MEMORY_SIZE, "1m");
@@ -664,16 +639,11 @@ public class OffHeapManagementDUnitTest extends JUnit4CacheTestCase {
/**
* Removes off heap region on vm and disconnects.
- *
- * @param vm a virutal machine.
+ *
+ * @param vm a virtual machine.
*/
- protected void doCleanupOnVm(VM vm) {
- vm.invoke(new SerializableRunnable() {
- @Override
- public void run() {
- cleanup();
- }
- });
+ private void doCleanupOnVm(final VM vm) {
+ vm.invoke(() -> cleanup());
}
/**
@@ -696,20 +666,14 @@ public class OffHeapManagementDUnitTest extends JUnit4CacheTestCase {
/**
* Asserts that the off heap region data is available and enabled for a VM.
*/
- @SuppressWarnings("serial")
- protected void assertOffHeapRegionAttributesOnVm(VM vm) {
- vm.invoke(new SerializableRunnable() {
- @Override
- public void run() {
- assertOffHeapRegionAttributes();
- }
- });
+ private void assertOffHeapRegionAttributesOnVm(final VM vm) {
+ vm.invoke(() -> assertOffHeapRegionAttributes());
}
/**
* Asserts that the off heap region data is available and enabled.
*/
- protected void assertOffHeapRegionAttributes() {
+ private void assertOffHeapRegionAttributes() {
ManagementService service = ManagementService.getExistingManagementService(getCache());
assertNotNull(service);
@@ -726,33 +690,28 @@ public class OffHeapManagementDUnitTest extends JUnit4CacheTestCase {
/**
* Asserts that OffHeapMetrics match input parameters for a VM.
- *
+ *
* @param vm a virtual machine.
* @param freeMemory total off-heap free memory in bytes.
* @param allocatedMemory allocated (or used) off-heap memory in bytes.
* @param objects number of objects stored in off-heap memory.
* @param fragmentation the fragmentation percentage.
*/
- protected void assertOffHeapMetricsOnVm(VM vm, final long freeMemory, final long allocatedMemory,
- final long objects, final int fragmentation) {
- vm.invoke(new SerializableRunnable() {
- @Override
- public void run() {
- assertOffHeapMetrics(freeMemory, allocatedMemory, objects, fragmentation);
- }
- });
+ private void assertOffHeapMetricsOnVm(final VM vm, final long freeMemory,
+ final long allocatedMemory, final long objects, final int fragmentation) {
+ vm.invoke(() -> assertOffHeapMetrics(freeMemory, allocatedMemory, objects, fragmentation));
}
/**
* Asserts that OffHeapMetrics match input parameters.
- *
+ *
* @param freeMemory total off-heap free memory in bytes.
* @param allocatedMemory allocated (or used) off-heap memory in bytes.
* @param objects number of objects stored in off-heap memory.
* @param fragmentation the fragmentation percentage.
*/
- protected void assertOffHeapMetrics(long freeMemory, long allocatedMemory, long objects,
- int fragmentation) {
+ private void assertOffHeapMetrics(final long freeMemory, final long allocatedMemory,
+ final long objects, final int fragmentation) {
ManagementService service = ManagementService.getExistingManagementService(getCache());
assertNotNull(service);
@@ -769,57 +728,49 @@ public class OffHeapManagementDUnitTest extends JUnit4CacheTestCase {
/**
* Creates an off-heap region on a vm.
- *
+ *
* @param vm a virtual machine.
* @param name a region name.
* @param dataPolicy a data policy.
+ *
* @return true if successful.
*/
- protected boolean createOffHeapRegionOnVm(final VM vm, final String name,
+ private boolean createOffHeapRegionOnVm(final VM vm, final String name,
final DataPolicy dataPolicy) {
- return (Boolean) vm.invoke(new SerializableCallable() {
- @Override
- public Object call() throws Exception {
- return (null != createOffHeapRegion(name, dataPolicy));
- }
- });
+ return vm.invoke(() -> null != createOffHeapRegion(name, dataPolicy));
}
/**
* Creates an off-heap region.
- *
+ *
* @param name a region name.
* @param dataPolicy a data policy.
+ *
* @return the newly created region.
*/
- protected Region createOffHeapRegion(String name, DataPolicy dataPolicy) {
+ private Region createOffHeapRegion(final String name, final DataPolicy dataPolicy) {
return getCache().createRegionFactory().setOffHeap(true).setDataPolicy(dataPolicy).create(name);
}
/**
* Sets the distributed system properties for a vm.
- *
+ *
* @param vm a virtual machine.
* @param management starts the ManagementService when true.
* @param props distributed system properties.
*/
- @SuppressWarnings("serial")
- protected void setSystemPropertiesOnVm(VM vm, final boolean management, final Properties props) {
- vm.invoke(new SerializableRunnable() {
- @Override
- public void run() {
- setSystemProperties(management, props);
- }
- });
+ private void setSystemPropertiesOnVm(final VM vm, final boolean management,
+ final Properties props) {
+ vm.invoke(() -> setSystemProperties(management, props));
}
/**
* Sets the distributed system properties.
- *
+ *
* @param management starts the ManagementService when true.
* @param props distributed system properties.
*/
- protected void setSystemProperties(boolean management, Properties props) {
+ private void setSystemProperties(final boolean management, final Properties props) {
getSystem(props);
if (management) {
@@ -832,27 +783,22 @@ public class OffHeapManagementDUnitTest extends JUnit4CacheTestCase {
/**
* Performs a destroy operation on a vm.
- *
+ *
* @param vm a virtual machine.
* @param key the region entry to destroy.
* @param regionName a region name.
*/
- protected void doDestroyOnVm(final VM vm, final Object key, final String regionName) {
- vm.invoke(new SerializableRunnable() {
- @Override
- public void run() {
- doDestroy(key, regionName);
- }
- });
+ private void doDestroyOnVm(final VM vm, final Object key, final String regionName) {
+ vm.invoke(() -> doDestroy(key, regionName));
}
/**
* Performs a destroy operation.
- *
+ *
* @param key the region entry to destroy.
* @param regionName a region name.
*/
- protected void doDestroy(Object key, String regionName) {
+ private void doDestroy(final Object key, final String regionName) {
Region region = getCache().getRegion(regionName);
assertNotNull(region);
@@ -861,59 +807,54 @@ public class OffHeapManagementDUnitTest extends JUnit4CacheTestCase {
/**
* Performs a put operation on a vm.
- *
+ *
* @param vm a virtual machine.
* @param key region entry key.
* @param value region entry value.
* @param regionName a region name.
*/
- protected void doPutOnVm(final VM vm, final Object key, final Object value,
- final String regionName, final boolean expectException) {
- vm.invoke(new SerializableRunnable() {
- @Override
- public void run() {
- doPut(key, value, regionName, expectException);
- }
- });
+ private void doPutOnVm(final VM vm, final Object key, final Object value, final String regionName,
+ final boolean expectException) {
+ vm.invoke(() -> doPut(key, value, regionName, expectException));
}
/**
* Performs a put operation.
- *
+ *
* @param key region entry key.
* @param value region entry value.
* @param regionName a region name.
*/
- protected void doPut(Object key, Object value, String regionName, boolean expectException) {
+ private void doPut(final Object key, final Object value, final String regionName,
+ final boolean expectException) {
Region region = getCache().getRegion(regionName);
assertNotNull(region);
try {
region.put(key, value);
+ if (expectException) {
+ fail("Expected OutOfOffHeapMemoryException");
+ }
} catch (OutOfOffHeapMemoryException e) {
- if (!expectException)
+ if (!expectException) {
throw e;
+ }
}
}
/**
* Adds an off-heap notification listener to the MemberMXBean for a vm.
- *
+ *
* @param vm a virtual machine.
*/
- protected void addOffHeapNotificationListenerOnVm(VM vm) {
- vm.invoke(new SerializableRunnable() {
- @Override
- public void run() {
- addOffHeapNotificationListener();
- }
- });
+ private void addOffHeapNotificationListenerOnVm(final VM vm) {
+ vm.invoke(() -> addOffHeapNotificationListener());
}
/**
* Adds an off-heap notification listener to the MemberMXBean.
*/
- protected void addOffHeapNotificationListener() {
+ private void addOffHeapNotificationListener() {
ManagementService service = ManagementService.getExistingManagementService(getCache());
assertNotNull(service);
@@ -929,116 +870,90 @@ public class OffHeapManagementDUnitTest extends JUnit4CacheTestCase {
/**
* Creates and adds a generic GaugeMonitor for an attribute of the MemberMXBean on a VM.
- *
+ *
* @param vm a virtual machine.
* @param attribute the attribute to monitor.
* @param highThreshold the high threshold trigger.
* @param lowThreshold the low threshold trigger.
*/
- protected void setupOffHeapMonitorOnVm(VM vm, final String attribute, final long highThreshold,
- final long lowThreshold) {
- vm.invoke(new SerializableRunnable() {
- @Override
- public void run() {
- setupOffHeapMonitor(attribute, highThreshold, lowThreshold);
- }
- });
+ private void setupOffHeapMonitorOnVm(final VM vm, final String attribute,
+ final long highThreshold, final long lowThreshold) {
+ vm.invoke(() -> setupOffHeapMonitor(attribute, highThreshold, lowThreshold));
}
/**
* Creates and adds a generic GaugeMonitor for an attribute of the MemberMXBean.
- *
+ *
* @param attribute the attribute to monitor.
* @param highThreshold the high threshold trigger.
* @param lowThreshold the low threshold trigger.
*/
- protected void setupOffHeapMonitor(String attribute, long highThreshold, long lowThreshold) {
+ private void setupOffHeapMonitor(final String attribute, final long highThreshold,
+ final long lowThreshold) throws JMException {
ObjectName memberMBeanObjectName = MBeanJMXAdapter.getMemberMBeanName(
InternalDistributedSystem.getConnectedInstance().getDistributedMember());
assertNotNull(memberMBeanObjectName);
- try {
- ObjectName offHeapMonitorName = new ObjectName("monitors:type=Gauge,attr=" + attribute);
- mbeanServer.createMBean("javax.management.monitor.GaugeMonitor", offHeapMonitorName);
-
- AttributeList al = new AttributeList();
- al.add(new Attribute("ObservedObject", memberMBeanObjectName));
- al.add(new Attribute("GranularityPeriod", 500));
- al.add(new Attribute("ObservedAttribute", attribute));
- al.add(new Attribute("Notify", true));
- al.add(new Attribute("NotifyHigh", true));
- al.add(new Attribute("NotifyLow", true));
- al.add(new Attribute("HighTheshold", highThreshold));
- al.add(new Attribute("LowThreshold", lowThreshold));
-
- mbeanServer.setAttributes(offHeapMonitorName, al);
- mbeanServer.addNotificationListener(offHeapMonitorName, notificationListener, null, null);
- mbeanServer.invoke(offHeapMonitorName, "start", new Object[] {}, new String[] {});
- } catch (Exception e) {
- fail(e.getMessage());
- }
+ ObjectName offHeapMonitorName = new ObjectName("monitors:type=Gauge,attr=" + attribute);
+ mbeanServer.createMBean("javax.management.monitor.GaugeMonitor", offHeapMonitorName);
+
+ AttributeList al = new AttributeList();
+ al.add(new Attribute("ObservedObject", memberMBeanObjectName));
+ al.add(new Attribute("GranularityPeriod", 500));
+ al.add(new Attribute("ObservedAttribute", attribute));
+ al.add(new Attribute("Notify", true));
+ al.add(new Attribute("NotifyHigh", true));
+ al.add(new Attribute("NotifyLow", true));
+ al.add(new Attribute("HighTheshold", highThreshold));
+ al.add(new Attribute("LowThreshold", lowThreshold));
+
+ mbeanServer.setAttributes(offHeapMonitorName, al);
+ mbeanServer.addNotificationListener(offHeapMonitorName, notificationListener, null, null);
+ mbeanServer.invoke(offHeapMonitorName, "start", new Object[] {}, new String[] {});
}
/**
* 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.
*/
- protected void waitForNotificationListenerOnVm(VM vm, final long wait, final long interval,
+ private void waitForNotificationListenerOnVm(final VM vm, final long wait, final long interval,
final boolean throwOnTimeout) {
- vm.invoke(new SerializableRunnable() {
- @Override
- public void run() {
- Wait.waitForCriterion(new WaitCriterion() {
- @Override
- public boolean done() {
- return (notificationListener.getNotificationSize() > 0);
- }
-
- @Override
- public String description() {
- return "Awaiting Notification Listener";
- }
- }, wait, interval, throwOnTimeout);
- }
- });
+ vm.invoke(() -> await("Awaiting Notification Listener").atMost(wait, TimeUnit.MILLISECONDS)
+ .until(() -> assertTrue(notificationListener.getNotificationSize() > 0)));
}
/**
* Clears received notifications.
- *
+ *
* @param vm a virtual machine.
*/
- protected void clearNotificationListenerOnVm(VM vm) {
- vm.invoke(new SerializableRunnable() {
- @Override
- public void run() {
- notificationListener.clear();
- }
- });
+ private void clearNotificationListenerOnVm(final VM vm) {
+ vm.invoke(() -> notificationListener.clear());
}
-}
+ /**
+ * Collects MBean Notifications.
+ */
+ private static class OffHeapNotificationListener implements NotificationListener {
-/**
- * Collects MBean Notifications.
- */
-class OffHeapNotificationListener implements NotificationListener {
- List<Notification> notificationList = Collections.synchronizedList(new ArrayList<Notification>());
+ List<Notification> notificationList =
+ Collections.synchronizedList(new ArrayList<Notification>());
- @Override
- public void handleNotification(Notification notification, Object handback) {
- this.notificationList.add(notification);
- }
+ @Override
+ public void handleNotification(final Notification notification, final Object handback) {
+ this.notificationList.add(notification);
+ }
- public void clear() {
- this.notificationList.clear();
- }
+ public void clear() {
+ this.notificationList.clear();
+ }
- public int getNotificationSize() {
- return this.notificationList.size();
+ public int getNotificationSize() {
+ return this.notificationList.size();
+ }
}
}