http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/eddef322/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/commands/QueueCommandsDUnitTest.java ---------------------------------------------------------------------- diff --git a/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/commands/QueueCommandsDUnitTest.java b/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/commands/QueueCommandsDUnitTest.java new file mode 100644 index 0000000..54aed63 --- /dev/null +++ b/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/commands/QueueCommandsDUnitTest.java @@ -0,0 +1,385 @@ +/* + * 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 com.gemstone.gemfire.management.internal.cli.commands; + +import com.gemstone.gemfire.cache.Cache; +import com.gemstone.gemfire.cache.asyncqueue.AsyncEventQueue; +import com.gemstone.gemfire.distributed.Locator; +import com.gemstone.gemfire.distributed.internal.DistributionConfig; +import com.gemstone.gemfire.distributed.internal.InternalLocator; +import com.gemstone.gemfire.distributed.internal.SharedConfiguration; +import com.gemstone.gemfire.internal.AvailablePort; +import com.gemstone.gemfire.internal.ClassBuilder; +import com.gemstone.gemfire.internal.FileUtil; +import com.gemstone.gemfire.management.cli.Result; +import com.gemstone.gemfire.management.internal.cli.i18n.CliStrings; +import com.gemstone.gemfire.management.internal.cli.result.CommandResult; +import com.gemstone.gemfire.management.internal.cli.util.CommandStringBuilder; +import dunit.DistributedTestCase; +import dunit.Host; +import dunit.SerializableRunnable; +import dunit.VM; + +import java.io.File; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.OutputStream; +import java.util.List; +import java.util.Properties; +import java.util.concurrent.CopyOnWriteArrayList; + +/** + * A distributed test suite of test cases for testing the queue commands that are part of Gfsh. + * + * @author David Hoots + * @since 8.0 + */ +public class QueueCommandsDUnitTest extends CliCommandTestBase { + private static final long serialVersionUID = 1L; + + final List<String> filesToBeDeleted = new CopyOnWriteArrayList<String>(); + + public QueueCommandsDUnitTest(final String testName) { + super(testName); + } + + public void testAsyncEventQueue() throws IOException { + final String queue1Name = "testAsyncEventQueue1"; + final String queue2Name = "testAsyncEventQueue2"; + final String diskStoreName = "testAsyncEventQueueDiskStore"; + + Properties localProps = new Properties(); + localProps.setProperty(DistributionConfig.GROUPS_NAME, "Group0"); + createDefaultSetup(localProps); + + CommandResult cmdResult = executeCommand(CliStrings.LIST_ASYNC_EVENT_QUEUES); + assertEquals(Result.Status.OK, cmdResult.getStatus()); + assertTrue(commandResultToString(cmdResult).contains("No Async Event Queues Found")); + + final VM vm1 = Host.getHost(0).getVM(1); + final String vm1Name = "VM" + vm1.getPid(); + final File diskStoreDir = new File(new File(".").getAbsolutePath(), diskStoreName); + this.filesToBeDeleted.add(diskStoreDir.getAbsolutePath()); + vm1.invoke(new SerializableRunnable() { + public void run() { + diskStoreDir.mkdirs(); + + Properties localProps = new Properties(); + localProps.setProperty(DistributionConfig.NAME_NAME, vm1Name); + localProps.setProperty(DistributionConfig.GROUPS_NAME, "Group1"); + getSystem(localProps); + getCache(); + } + }); + + final VM vm2 = Host.getHost(0).getVM(2); + final String vm2Name = "VM" + vm2.getPid(); + vm2.invoke(new SerializableRunnable() { + public void run() { + Properties localProps = new Properties(); + localProps.setProperty(DistributionConfig.NAME_NAME, vm2Name); + localProps.setProperty(DistributionConfig.GROUPS_NAME, "Group2"); + getSystem(localProps); + getCache(); + } + }); + + // Deploy a JAR file with an AsyncEventListener/GatewayEventFilter/GatewayEventSubstitutionFilter + // that can be instantiated on each server + final File jarFile = new File(new File(".").getAbsolutePath(), "QueueCommandsDUnit.jar"); + QueueCommandsDUnitTest.this.filesToBeDeleted.add(jarFile.getAbsolutePath()); + + ClassBuilder classBuilder = new ClassBuilder(); + byte[] jarBytes = classBuilder.createJarFromClassContent("com/qcdunit/QueueCommandsDUnitTestHelper", + "package com.qcdunit;" + + "import java.util.List; import java.util.Properties;" + + "import com.gemstone.gemfire.internal.cache.xmlcache.Declarable2; import com.gemstone.gemfire.cache.asyncqueue.AsyncEvent;" + + "import com.gemstone.gemfire.cache.wan.GatewayEventFilter; import com.gemstone.gemfire.cache.wan.GatewayEventSubstitutionFilter;" + + "import com.gemstone.gemfire.cache.asyncqueue.AsyncEventListener; import com.gemstone.gemfire.cache.wan.GatewayQueueEvent;" + + "import com.gemstone.gemfire.cache.EntryEvent;" + + "public class QueueCommandsDUnitTestHelper implements Declarable2, GatewayEventFilter, GatewayEventSubstitutionFilter, AsyncEventListener {" + + "Properties props;" + + "public boolean processEvents(List<AsyncEvent> events) { return true; }" + + "public void afterAcknowledgement(GatewayQueueEvent event) {}" + + "public boolean beforeEnqueue(GatewayQueueEvent event) { return true; }" + + "public boolean beforeTransmit(GatewayQueueEvent event) { return true; }" + + "public Object getSubstituteValue(EntryEvent event) { return null; }" + + "public void close() {}" + + "public void init(final Properties props) {this.props = props;}" + + "public Properties getConfig() {return this.props;}}"); + writeJarBytesToFile(jarFile, jarBytes); + + cmdResult = executeCommand("deploy --jar=QueueCommandsDUnit.jar"); + assertEquals(Result.Status.OK, cmdResult.getStatus()); + + CommandStringBuilder commandStringBuilder = new CommandStringBuilder(CliStrings.CREATE_DISK_STORE); + commandStringBuilder.addOption(CliStrings.CREATE_DISK_STORE__NAME, diskStoreName); + commandStringBuilder.addOption(CliStrings.CREATE_DISK_STORE__GROUP, "Group1"); + commandStringBuilder.addOption(CliStrings.CREATE_DISK_STORE__DIRECTORY_AND_SIZE, diskStoreDir.getAbsolutePath()); + cmdResult = executeCommand(commandStringBuilder.toString()); + assertEquals(Result.Status.OK, cmdResult.getStatus()); + String stringResult = commandResultToString(cmdResult); + assertEquals(3, countLinesInString(stringResult, false)); + assertEquals(false, stringResult.contains("ERROR")); + assertTrue(stringContainsLine(stringResult, vm1Name + ".*Success")); + + commandStringBuilder = new CommandStringBuilder(CliStrings.CREATE_ASYNC_EVENT_QUEUE); + commandStringBuilder.addOption(CliStrings.CREATE_ASYNC_EVENT_QUEUE__ID, queue1Name); + commandStringBuilder.addOption(CliStrings.CREATE_ASYNC_EVENT_QUEUE__GROUP, "Group1"); + commandStringBuilder.addOption(CliStrings.CREATE_ASYNC_EVENT_QUEUE__BATCH_SIZE, "514"); + commandStringBuilder.addOption(CliStrings.CREATE_ASYNC_EVENT_QUEUE__PERSISTENT, "true"); + commandStringBuilder.addOption(CliStrings.CREATE_ASYNC_EVENT_QUEUE__DISK_STORE, diskStoreName); + commandStringBuilder.addOption(CliStrings.CREATE_ASYNC_EVENT_QUEUE__MAXIMUM_QUEUE_MEMORY, "213"); + commandStringBuilder.addOption(CliStrings.CREATE_ASYNC_EVENT_QUEUE__BATCHTIMEINTERVAL, "946"); + commandStringBuilder.addOption(CliStrings.CREATE_ASYNC_EVENT_QUEUE__PARALLEL, "true"); + commandStringBuilder.addOption(CliStrings.CREATE_ASYNC_EVENT_QUEUE__ENABLEBATCHCONFLATION, "true"); + commandStringBuilder.addOption(CliStrings.CREATE_ASYNC_EVENT_QUEUE__DISPATCHERTHREADS, "2"); + commandStringBuilder.addOption(CliStrings.CREATE_ASYNC_EVENT_QUEUE__ORDERPOLICY, "PARTITION"); + commandStringBuilder.addOption(CliStrings.CREATE_ASYNC_EVENT_QUEUE__GATEWAYEVENTFILTER, + "com.qcdunit.QueueCommandsDUnitTestHelper"); + commandStringBuilder.addOption(CliStrings.CREATE_ASYNC_EVENT_QUEUE__SUBSTITUTION_FILTER, + "com.qcdunit.QueueCommandsDUnitTestHelper"); + commandStringBuilder.addOption(CliStrings.CREATE_ASYNC_EVENT_QUEUE__DISKSYNCHRONOUS, "false"); + commandStringBuilder.addOption(CliStrings.CREATE_ASYNC_EVENT_QUEUE__LISTENER, + "com.qcdunit.QueueCommandsDUnitTestHelper"); + commandStringBuilder.addOption(CliStrings.CREATE_ASYNC_EVENT_QUEUE__LISTENER_PARAM_AND_VALUE, "param1"); + commandStringBuilder.addOption(CliStrings.CREATE_ASYNC_EVENT_QUEUE__LISTENER_PARAM_AND_VALUE, "param2#value2"); + cmdResult = executeCommand(commandStringBuilder.toString()); + assertEquals(Result.Status.OK, cmdResult.getStatus()); + stringResult = commandResultToString(cmdResult); + assertEquals(3, countLinesInString(stringResult, false)); + assertEquals(false, stringResult.contains("ERROR")); + assertTrue(stringContainsLine(stringResult, vm1Name + ".*Success")); + + // Verify that the queue was created on the correct member + cmdResult = executeCommand(CliStrings.LIST_ASYNC_EVENT_QUEUES); + assertEquals(Result.Status.OK, cmdResult.getStatus()); + stringResult = commandResultToString(cmdResult); + assertEquals(3, countLinesInString(stringResult, false)); + assertTrue(stringContainsLine(stringResult, + vm1Name + " .*" + queue1Name + " .*514 .*true .*" + diskStoreName + " .*213 .*" + " .*com.qcdunit.QueueCommandsDUnitTestHelper" + ".*")); + assertTrue(stringContainsLine(stringResult, vm1Name + ".*param2=value2.*")); + assertTrue(stringContainsLine(stringResult, vm1Name + ".*param1=[^\\w].*")); + assertFalse(stringContainsLine(stringResult, vm2Name + ".*" + queue1Name + ".*")); + + vm1.invoke(new SerializableRunnable() { + public void run() { + Cache cache = getCache(); + AsyncEventQueue queue = cache.getAsyncEventQueue(queue1Name); + assertEquals(queue.getBatchSize(), 514); + assertEquals(queue.isPersistent(), true); + assertEquals(queue.getDiskStoreName(), diskStoreName); + assertEquals(queue.getMaximumQueueMemory(), 213); + assertEquals(queue.getBatchTimeInterval(), 946); + assertEquals(queue.isParallel(), true); + assertEquals(queue.isBatchConflationEnabled(), true); + assertEquals(queue.getDispatcherThreads(), 2); + assertEquals(queue.getOrderPolicy().toString(), "PARTITION"); + assertEquals(queue.getGatewayEventFilters().size(), 1); + assertEquals(queue.getGatewayEventFilters().get(0).getClass().getName(), + "com.qcdunit.QueueCommandsDUnitTestHelper"); + assertEquals(queue.getGatewayEventSubstitutionFilter().getClass().getName(), + "com.qcdunit.QueueCommandsDUnitTestHelper"); + assertEquals(queue.isDiskSynchronous(), false); + assertEquals(queue.getAsyncEventListener().getClass().getName(), "com.qcdunit.QueueCommandsDUnitTestHelper"); + } + }); + + commandStringBuilder = new CommandStringBuilder(CliStrings.CREATE_ASYNC_EVENT_QUEUE); + commandStringBuilder.addOption(CliStrings.CREATE_ASYNC_EVENT_QUEUE__ID, queue2Name); + commandStringBuilder.addOption(CliStrings.CREATE_ASYNC_EVENT_QUEUE__LISTENER, + "com.qcdunit.QueueCommandsDUnitTestHelper"); + cmdResult = executeCommand(commandStringBuilder.toString()); + assertEquals(Result.Status.OK, cmdResult.getStatus()); + stringResult = commandResultToString(cmdResult); + assertEquals(5, countLinesInString(stringResult, false)); + assertTrue(stringContainsLine(stringResult, "Manager.*Success")); + assertTrue(stringContainsLine(stringResult, vm2Name + ".*Success")); + assertTrue(stringContainsLine(stringResult, vm1Name + ".*Success")); + + // Verify that the queue was created on the correct members + cmdResult = executeCommand(CliStrings.LIST_ASYNC_EVENT_QUEUES); + assertEquals(Result.Status.OK, cmdResult.getStatus()); + stringResult = commandResultToString(cmdResult); + assertEquals(6, countLinesInString(stringResult, false)); + assertTrue(stringContainsLine(stringResult, + "Manager .*" + queue2Name + " .*100 .*false .*null .*100 .*" + " .*com.qcdunit.QueueCommandsDUnitTestHelper")); + assertTrue(stringContainsLine(stringResult, + vm1Name + " .*" + queue1Name + " .*514 .*true .*" + diskStoreName + " .*213 .*" + " .*com.qcdunit.QueueCommandsDUnitTestHelper" + ".*")); + assertTrue(stringContainsLine(stringResult, + vm1Name + " .*" + queue2Name + " .*100 .*false .*null .*100 .*" + " .*com.qcdunit.QueueCommandsDUnitTestHelper")); + assertTrue(stringContainsLine(stringResult, + vm2Name + " .*" + queue2Name + " .*100 .*false .*null .*100 .*" + " .*com.qcdunit.QueueCommandsDUnitTestHelper")); + } + + /** + * Asserts that creating async event queues correctly updates the shared configuration. + */ + public void testCreateUpdatesSharedConfig() throws IOException { + disconnectAllFromDS(); + + final String queueName = "testAsyncEventQueueQueue"; + final String groupName = "testAsyncEventQueueSharedConfigGroup"; + + // Start the Locator and wait for shared configuration to be available + final int locatorPort = AvailablePort.getRandomAvailablePort(AvailablePort.SOCKET); + Host.getHost(0).getVM(3).invoke(new SerializableRunnable() { + @Override + public void run() { + + final File locatorLogFile = new File("locator-" + locatorPort + ".log"); + final Properties locatorProps = new Properties(); + locatorProps.setProperty(DistributionConfig.NAME_NAME, "Locator"); + locatorProps.setProperty(DistributionConfig.MCAST_PORT_NAME, "0"); + locatorProps.setProperty(DistributionConfig.LOG_LEVEL_NAME, "fine"); + locatorProps.setProperty(DistributionConfig.ENABLE_CLUSTER_CONFIGURATION_NAME, "true"); + try { + final InternalLocator locator = (InternalLocator) Locator.startLocatorAndDS(locatorPort, locatorLogFile, null, + locatorProps); + + DistributedTestCase.WaitCriterion wc = new DistributedTestCase.WaitCriterion() { + @Override + public boolean done() { + return locator.isSharedConfigurationRunning(); + } + + @Override + public String description() { + return "Waiting for shared configuration to be started"; + } + }; + DistributedTestCase.waitForCriterion(wc, 5000, 500, true); + } catch (IOException ioex) { + fail("Unable to create a locator with a shared configuration"); + } + } + }); + + // Start the default manager + Properties managerProps = new Properties(); + managerProps.setProperty(DistributionConfig.MCAST_PORT_NAME, "0"); + managerProps.setProperty(DistributionConfig.LOCATORS_NAME, "localhost:" + locatorPort); + createDefaultSetup(managerProps); + + // Create a cache in VM 1 + VM vm = Host.getHost(0).getVM(1); + vm.invoke(new SerializableRunnable() { + @Override + public void run() { + Properties localProps = new Properties(); + localProps.setProperty(DistributionConfig.MCAST_PORT_NAME, "0"); + localProps.setProperty(DistributionConfig.LOCATORS_NAME, "localhost:" + locatorPort); + localProps.setProperty(DistributionConfig.GROUPS_NAME, groupName); + getSystem(localProps); + assertNotNull(getCache()); + } + }); + + // Deploy a JAR file with an AsyncEventListener that can be instantiated on each server + final File jarFile = new File(new File(".").getAbsolutePath(), "QueueCommandsDUnit.jar"); + QueueCommandsDUnitTest.this.filesToBeDeleted.add(jarFile.getAbsolutePath()); + + ClassBuilder classBuilder = new ClassBuilder(); + byte[] jarBytes = classBuilder.createJarFromClassContent("com/qcdunit/QueueCommandsDUnitTestListener", + "package com.qcdunit;" + + "import java.util.List; import java.util.Properties;" + + "import com.gemstone.gemfire.internal.cache.xmlcache.Declarable2; import com.gemstone.gemfire.cache.asyncqueue.AsyncEvent;" + + "import com.gemstone.gemfire.cache.asyncqueue.AsyncEventListener;" + + "public class QueueCommandsDUnitTestListener implements Declarable2, AsyncEventListener {" + + "Properties props;" + + "public boolean processEvents(List<AsyncEvent> events) { return true; }" + + "public void close() {}" + + "public void init(final Properties props) {this.props = props;}" + + "public Properties getConfig() {return this.props;}}"); + writeJarBytesToFile(jarFile, jarBytes); + + CommandResult cmdResult = executeCommand("deploy --jar=QueueCommandsDUnit.jar"); + assertEquals(Result.Status.OK, cmdResult.getStatus()); + + // Test creating the queue + CommandStringBuilder commandStringBuilder = new CommandStringBuilder(CliStrings.CREATE_ASYNC_EVENT_QUEUE); + commandStringBuilder.addOption(CliStrings.CREATE_ASYNC_EVENT_QUEUE__ID, queueName); + commandStringBuilder.addOption(CliStrings.CREATE_ASYNC_EVENT_QUEUE__GROUP, groupName); + commandStringBuilder.addOption(CliStrings.CREATE_ASYNC_EVENT_QUEUE__LISTENER, + "com.qcdunit.QueueCommandsDUnitTestListener"); + cmdResult = executeCommand(commandStringBuilder.toString()); + assertEquals(Result.Status.OK, cmdResult.getStatus()); + + // Make sure the queue exists in the shared config + Host.getHost(0).getVM(3).invoke(new SerializableRunnable() { + @Override + public void run() { + SharedConfiguration sharedConfig = ((InternalLocator) Locator.getLocator()).getSharedConfiguration(); + String xmlFromConfig; + try { + xmlFromConfig = sharedConfig.getConfiguration(groupName).getCacheXmlContent(); + assertTrue(xmlFromConfig.contains(queueName)); + } catch (Exception e) { + fail("Error occurred in cluster configuration service", e); + } + } + }); + + //Close cache in the vm1 and restart it to get the shared configuration + vm = Host.getHost(0).getVM(1); + vm.invoke(new SerializableRunnable() { + @Override + public void run() { + Cache cache = getCache(); + assertNotNull(cache); + cache.close(); + + assertTrue(cache.isClosed()); + + Properties localProps = new Properties(); + localProps.setProperty(DistributionConfig.MCAST_PORT_NAME, "0"); + localProps.setProperty(DistributionConfig.LOCATORS_NAME, "localhost:" + locatorPort); + localProps.setProperty(DistributionConfig.GROUPS_NAME, groupName); + localProps.setProperty(DistributionConfig.USE_CLUSTER_CONFIGURATION_NAME, "true"); + getSystem(localProps); + cache = getCache(); + assertNotNull(cache); + AsyncEventQueue aeq = cache.getAsyncEventQueue(queueName); + + assertNotNull(aeq); + } + }); + } + + @Override + public void tearDown2() throws Exception { + for (String path : this.filesToBeDeleted) { + try { + final File fileToDelete = new File(path); + FileUtil.delete(fileToDelete); + if (path.endsWith(".jar")) { + executeCommand("undeploy --jar=" + fileToDelete.getName()); + } + } catch (IOException e) { + getLogWriter().error("Unable to delete file", e); + } + } + this.filesToBeDeleted.clear(); + super.tearDown2(); + } + + private void writeJarBytesToFile(File jarFile, byte[] jarBytes) throws IOException { + final OutputStream outStream = new FileOutputStream(jarFile); + outStream.write(jarBytes); + outStream.close(); + } +}
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/eddef322/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/commands/SharedConfigurationCommandsDUnitTest.java ---------------------------------------------------------------------- diff --git a/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/commands/SharedConfigurationCommandsDUnitTest.java b/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/commands/SharedConfigurationCommandsDUnitTest.java new file mode 100644 index 0000000..adf5b5f --- /dev/null +++ b/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/commands/SharedConfigurationCommandsDUnitTest.java @@ -0,0 +1,338 @@ +/* + * 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 com.gemstone.gemfire.management.internal.cli.commands; + +import com.gemstone.gemfire.cache.Cache; +import com.gemstone.gemfire.cache.CacheFactory; +import com.gemstone.gemfire.distributed.DistributedMember; +import com.gemstone.gemfire.distributed.Locator; +import com.gemstone.gemfire.distributed.internal.DistributionConfig; +import com.gemstone.gemfire.distributed.internal.InternalLocator; +import com.gemstone.gemfire.distributed.internal.SharedConfiguration; +import com.gemstone.gemfire.internal.AvailablePortHelper; +import com.gemstone.gemfire.internal.ClassBuilder; +import com.gemstone.gemfire.management.cli.Result; +import com.gemstone.gemfire.management.cli.Result.Status; +import com.gemstone.gemfire.management.internal.cli.CliUtil; +import com.gemstone.gemfire.management.internal.cli.HeadlessGfsh; +import com.gemstone.gemfire.management.internal.cli.i18n.CliStrings; +import com.gemstone.gemfire.management.internal.cli.result.CommandResult; +import com.gemstone.gemfire.management.internal.cli.util.CommandStringBuilder; +import com.gemstone.gemfire.management.internal.configuration.SharedConfigurationDUnitTest; +import com.gemstone.gemfire.management.internal.configuration.domain.Configuration; +import dunit.DistributedTestCase; +import dunit.Host; +import dunit.SerializableCallable; +import dunit.SerializableRunnable; +import dunit.VM; +import org.apache.commons.io.FileUtils; + +import java.io.File; +import java.io.IOException; +import java.net.InetAddress; +import java.net.UnknownHostException; +import java.util.Properties; +import java.util.Set; + +/*** + * DUnit test to test export and import of shared configuration. + * + * @author bansods + */ +public class SharedConfigurationCommandsDUnitTest extends CliCommandTestBase { + + private static final long serialVersionUID = 1L; + private static final int TIMEOUT = 10000; + private static final int INTERVAL = 500; + + public SharedConfigurationCommandsDUnitTest(String name) { + super(name); + } + + File newDeployableJarFile = new File("DeployCommandsDUnit1.jar"); + private transient ClassBuilder classBuilder = new ClassBuilder(); + + @SuppressWarnings("unchecked") + public void testExportImportSharedConfiguration() { + disconnectAllFromDS(); + + final String region1Name = "r1"; + final String region2Name = "r2"; + final String groupName = "testRegionSharedConfigGroup"; + final String sharedConfigZipFileName = "sharedConfig.zip"; + final String deployedJarName = "DeployCommandsDUnit1.jar"; + final String logLevel = "info"; + final String startArchiveFileName = "stats.gfs"; + final int[] ports = AvailablePortHelper.getRandomAvailableTCPPorts(3); + + // TODO Sourabh - the code below is similar to CliCommandTestBase.createDefaultSetup(..); we may want to consider + // refactoring this and combine the duplicate code blocks using either the Template Method and/or Strategy design + // patterns. We can talk about this. + // Start the Locator and wait for shared configuration to be available + final int locator1Port = ports[0]; + final String locator1Name = "locator1-" + locator1Port; + VM locatorAndMgr = Host.getHost(0).getVM(3); + Object[] result = (Object[]) locatorAndMgr.invoke(new SerializableCallable() { + @Override + public Object call() { + int httpPort; + int jmxPort; + String jmxHost; + + try { + jmxHost = InetAddress.getLocalHost().getHostName(); + } catch (UnknownHostException ignore) { + jmxHost = "localhost"; + } + + final int[] ports = AvailablePortHelper.getRandomAvailableTCPPorts(2); + + jmxPort = ports[0]; + httpPort = ports[1]; + + final File locatorLogFile = new File("locator-" + locator1Port + ".log"); + + final Properties locatorProps = new Properties(); + locatorProps.setProperty(DistributionConfig.NAME_NAME, locator1Name); + locatorProps.setProperty(DistributionConfig.MCAST_PORT_NAME, "0"); + locatorProps.setProperty(DistributionConfig.LOG_LEVEL_NAME, "config"); + locatorProps.setProperty(DistributionConfig.ENABLE_CLUSTER_CONFIGURATION_NAME, "true"); + locatorProps.setProperty(DistributionConfig.JMX_MANAGER_NAME, "true"); + locatorProps.setProperty(DistributionConfig.JMX_MANAGER_START_NAME, "true"); + locatorProps.setProperty(DistributionConfig.JMX_MANAGER_BIND_ADDRESS_NAME, String.valueOf(jmxHost)); + locatorProps.setProperty(DistributionConfig.JMX_MANAGER_PORT_NAME, String.valueOf(jmxPort)); + locatorProps.setProperty(DistributionConfig.HTTP_SERVICE_PORT_NAME, String.valueOf(httpPort)); + + try { + final InternalLocator locator = (InternalLocator) Locator.startLocatorAndDS(locator1Port, locatorLogFile, + null, locatorProps); + DistributedTestCase.WaitCriterion wc = new DistributedTestCase.WaitCriterion() { + @Override + public boolean done() { + return locator.isSharedConfigurationRunning(); + } + + @Override + public String description() { + return "Waiting for shared configuration to be started"; + } + }; + DistributedTestCase.waitForCriterion(wc, TIMEOUT, INTERVAL, true); + } catch (IOException ioex) { + fail("Unable to create a locator with a shared configuration"); + } + + final Object[] result = new Object[4]; + result[0] = jmxHost; + result[1] = jmxPort; + result[2] = httpPort; + result[3] = CliUtil.getAllNormalMembers(CacheFactory.getAnyInstance()); + + return result; + } + }); + + HeadlessGfsh gfsh = getDefaultShell(); + String jmxHost = (String) result[0]; + int jmxPort = (Integer) result[1]; + int httpPort = (Integer) result[2]; + Set<DistributedMember> normalMembers1 = (Set<DistributedMember>) result[3]; + + shellConnect(jmxHost, jmxPort, httpPort, gfsh); + // Create a cache in VM 1 + VM dataMember = Host.getHost(0).getVM(1); + normalMembers1 = (Set<DistributedMember>) dataMember.invoke(new SerializableCallable() { + @Override + public Object call() { + Properties localProps = new Properties(); + localProps.setProperty(DistributionConfig.MCAST_PORT_NAME, "0"); + localProps.setProperty(DistributionConfig.LOCATORS_NAME, "localhost:" + locator1Port); + localProps.setProperty(DistributionConfig.GROUPS_NAME, groupName); + localProps.setProperty(DistributionConfig.NAME_NAME, "DataMember"); + getSystem(localProps); + Cache cache = getCache(); + assertNotNull(cache); + return CliUtil.getAllNormalMembers(cache); + } + }); + // Create a JAR file + try { + this.classBuilder.writeJarFromName("DeployCommandsDUnitA", this.newDeployableJarFile); + } catch (IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + + // Deploy the JAR + CommandResult cmdResult = executeCommand("deploy --jar=" + deployedJarName); + assertEquals(Result.Status.OK, cmdResult.getStatus()); + //Create the region1 on the group + CommandStringBuilder commandStringBuilder = new CommandStringBuilder(CliStrings.CREATE_REGION); + commandStringBuilder.addOption(CliStrings.CREATE_REGION__REGION, region1Name); + commandStringBuilder.addOption(CliStrings.CREATE_REGION__REGIONSHORTCUT, "REPLICATE"); + commandStringBuilder.addOption(CliStrings.CREATE_REGION__STATISTICSENABLED, "true"); + commandStringBuilder.addOption(CliStrings.CREATE_REGION__GROUP, groupName); + + cmdResult = executeCommand(commandStringBuilder.toString()); + assertEquals(Result.Status.OK, cmdResult.getStatus()); + + commandStringBuilder = new CommandStringBuilder(CliStrings.CREATE_REGION); + commandStringBuilder.addOption(CliStrings.CREATE_REGION__REGION, region2Name); + commandStringBuilder.addOption(CliStrings.CREATE_REGION__REGIONSHORTCUT, "PARTITION"); + commandStringBuilder.addOption(CliStrings.CREATE_REGION__STATISTICSENABLED, "true"); + cmdResult = executeCommand(commandStringBuilder.toString()); + assertEquals(Result.Status.OK, cmdResult.getStatus()); + + //Alter runtime configuration + commandStringBuilder = new CommandStringBuilder(CliStrings.ALTER_RUNTIME_CONFIG); + commandStringBuilder.addOption(CliStrings.ALTER_RUNTIME_CONFIG__LOG__LEVEL, logLevel); + commandStringBuilder.addOption(CliStrings.ALTER_RUNTIME_CONFIG__LOG__FILE__SIZE__LIMIT, "50"); + commandStringBuilder.addOption(CliStrings.ALTER_RUNTIME_CONFIG__ARCHIVE__DISK__SPACE__LIMIT, "32"); + commandStringBuilder.addOption(CliStrings.ALTER_RUNTIME_CONFIG__ARCHIVE__FILE__SIZE__LIMIT, "49"); + commandStringBuilder.addOption(CliStrings.ALTER_RUNTIME_CONFIG__STATISTIC__SAMPLE__RATE, "120"); + commandStringBuilder.addOption(CliStrings.ALTER_RUNTIME_CONFIG__STATISTIC__ARCHIVE__FILE, startArchiveFileName); + commandStringBuilder.addOption(CliStrings.ALTER_RUNTIME_CONFIG__STATISTIC__SAMPLING__ENABLED, "true"); + commandStringBuilder.addOption(CliStrings.ALTER_RUNTIME_CONFIG__LOG__DISK__SPACE__LIMIT, "10"); + cmdResult = executeCommand(commandStringBuilder.getCommandString()); + String resultString = commandResultToString(cmdResult); + + getLogWriter().info("#SB Result\n"); + getLogWriter().info(resultString); + assertEquals(true, cmdResult.getStatus().equals(Status.OK)); + + commandStringBuilder = new CommandStringBuilder(CliStrings.STATUS_SHARED_CONFIG); + cmdResult = executeCommand(commandStringBuilder.getCommandString()); + resultString = commandResultToString(cmdResult); + getLogWriter().info("#SB Result\n"); + getLogWriter().info(resultString); + assertEquals(Status.OK, cmdResult.getStatus()); + + commandStringBuilder = new CommandStringBuilder(CliStrings.EXPORT_SHARED_CONFIG); + commandStringBuilder.addOption(CliStrings.EXPORT_SHARED_CONFIG__FILE, sharedConfigZipFileName); + cmdResult = executeCommand(commandStringBuilder.getCommandString()); + resultString = commandResultToString(cmdResult); + getLogWriter().info("#SB Result\n"); + getLogWriter().info(resultString); + assertEquals(Status.OK, cmdResult.getStatus()); + + //Import into a running system should fail + commandStringBuilder = new CommandStringBuilder(CliStrings.IMPORT_SHARED_CONFIG); + commandStringBuilder.addOption(CliStrings.IMPORT_SHARED_CONFIG__ZIP, sharedConfigZipFileName); + cmdResult = executeCommand(commandStringBuilder.getCommandString()); + assertEquals(Status.ERROR, cmdResult.getStatus()); + + //Stop the data members and remove the shared configuration in the locator. + dataMember.invoke(new SerializableCallable() { + @Override + public Object call() throws Exception { + Cache cache = getCache(); + cache.close(); + assertTrue(cache.isClosed()); + disconnectFromDS(); + return null; + } + }); + + //Clear shared configuration in this locator to test the import shared configuration + locatorAndMgr.invoke(new SerializableCallable() { + @Override + public Object call() throws Exception { + InternalLocator locator = InternalLocator.getLocator(); + SharedConfiguration sc = locator.getSharedConfiguration(); + assertNotNull(sc); + sc.clearSharedConfiguration(); + return null; + } + }); + + //Now execute import shared configuration + //Now import the shared configuration and it should succeed. + commandStringBuilder = new CommandStringBuilder(CliStrings.IMPORT_SHARED_CONFIG); + commandStringBuilder.addOption(CliStrings.IMPORT_SHARED_CONFIG__ZIP, sharedConfigZipFileName); + cmdResult = executeCommand(commandStringBuilder.getCommandString()); + assertEquals(Status.OK, cmdResult.getStatus()); + + //Start a new locator , test if it has all the imported shared configuration artifacts + VM newLocator = Host.getHost(0).getVM(2); + final int locator2Port = ports[1]; + final String locator2Name = "Locator2-" + locator2Port; + + newLocator.invoke(new SerializableRunnable() { + @Override + public void run() { + final File locatorLogFile = new File("locator-" + locator2Port + ".log"); + final Properties locatorProps = new Properties(); + locatorProps.setProperty(DistributionConfig.NAME_NAME, locator2Name); + locatorProps.setProperty(DistributionConfig.MCAST_PORT_NAME, "0"); + locatorProps.setProperty(DistributionConfig.LOG_LEVEL_NAME, "fine"); + locatorProps.setProperty(DistributionConfig.ENABLE_CLUSTER_CONFIGURATION_NAME, "true"); + locatorProps.setProperty(DistributionConfig.LOCATORS_NAME, "localhost:" + locator1Port); + + try { + final InternalLocator locator = (InternalLocator) Locator.startLocatorAndDS(locator2Port, locatorLogFile, + null, locatorProps); + + DistributedTestCase.WaitCriterion wc = new DistributedTestCase.WaitCriterion() { + @Override + public boolean done() { + return locator.isSharedConfigurationRunning(); + } + + @Override + public String description() { + return "Waiting for shared configuration to be started"; + } + }; + DistributedTestCase.waitForCriterion(wc, 5000, 500, true); + + SharedConfiguration sc = locator.getSharedConfiguration(); + assertNotNull(sc); + Configuration groupConfig = sc.getConfiguration(groupName); + assertNotNull(groupConfig); + assertTrue(groupConfig.getCacheXmlContent().contains(region1Name)); + + Configuration clusterConfig = sc.getConfiguration(SharedConfiguration.CLUSTER_CONFIG); + assertNotNull(clusterConfig); + assertTrue(clusterConfig.getCacheXmlContent().contains(region2Name)); + assertTrue(clusterConfig.getJarNames().contains(deployedJarName)); + assertTrue( + clusterConfig.getGemfireProperties().getProperty(DistributionConfig.LOG_LEVEL_NAME).equals(logLevel)); + assertTrue( + clusterConfig.getGemfireProperties().getProperty(DistributionConfig.STATISTIC_ARCHIVE_FILE_NAME).equals( + startArchiveFileName)); + } catch (IOException ioex) { + fail("Unable to create a locator with a shared configuration"); + } catch (Exception e) { + fail("Error occurred in cluster configuration service", e); + } + } + }); + + //Clean up + File sharedConfigZipFile = new File(sharedConfigZipFileName); + FileUtils.deleteQuietly(sharedConfigZipFile); + FileUtils.deleteQuietly(newDeployableJarFile); + } + + @Override + public void tearDown2() throws Exception { + super.tearDown2(); + for (int i = 0; i < 4; i++) { + Host.getHost(0).getVM(i).invoke(SharedConfigurationDUnitTest.locatorCleanup); + } + } +} http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/eddef322/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/commands/ShellCommandsDUnitTest.java ---------------------------------------------------------------------- diff --git a/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/commands/ShellCommandsDUnitTest.java b/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/commands/ShellCommandsDUnitTest.java new file mode 100644 index 0000000..0fc6be4 --- /dev/null +++ b/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/commands/ShellCommandsDUnitTest.java @@ -0,0 +1,365 @@ +/* + * 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 com.gemstone.gemfire.management.internal.cli.commands; + +import com.gemstone.gemfire.distributed.AbstractLauncher.Status; +import com.gemstone.gemfire.distributed.LocatorLauncher; +import com.gemstone.gemfire.distributed.LocatorLauncher.LocatorState; +import com.gemstone.gemfire.internal.AvailablePortHelper; +import com.gemstone.gemfire.internal.lang.StringUtils; +import com.gemstone.gemfire.internal.util.IOUtils; +import com.gemstone.gemfire.management.cli.Result; +import com.gemstone.gemfire.management.internal.cli.domain.DataCommandRequest; +import com.gemstone.gemfire.management.internal.cli.i18n.CliStrings; +import com.gemstone.gemfire.management.internal.cli.result.CommandResult; +import com.gemstone.gemfire.management.internal.cli.shell.Gfsh; +import com.gemstone.gemfire.management.internal.cli.util.CommandStringBuilder; +import org.junit.Before; + +import java.io.File; +import java.util.concurrent.TimeUnit; + +public class ShellCommandsDUnitTest extends CliCommandTestBase { + + private static final long serialVersionUID = 1L; + + public ShellCommandsDUnitTest(String name) { + super(name); + } + + @Before + @Override + public void setUp() throws Exception { + super.setUp(); + getDefaultShell(); + } + + protected CommandResult connectToLocator(final int locatorPort) { + return executeCommand(new CommandStringBuilder(CliStrings.CONNECT).addOption(CliStrings.CONNECT__LOCATOR, + "localhost[" + locatorPort + "]").toString()); + } + + public void testConnectToLocatorBecomesManager() { + final int[] ports = AvailablePortHelper.getRandomAvailableTCPPorts(2); + + final int jmxManagerPort = ports[0]; + final int locatorPort = ports[1]; + + System.setProperty("gemfire.jmx-manager-port", String.valueOf(jmxManagerPort)); + System.setProperty("gemfire.jmx-manager-http-port", "0"); + + assertEquals(String.valueOf(jmxManagerPort), System.getProperty("gemfire.jmx-manager-port")); + assertEquals("0", System.getProperty("gemfire.jmx-manager-http-port")); + + final String pathname = (getClass().getSimpleName() + "_" + getTestName()); + final File workingDirectory = new File(pathname); + + workingDirectory.mkdir(); + + assertTrue(workingDirectory.isDirectory()); + + final LocatorLauncher locatorLauncher = new LocatorLauncher.Builder().setBindAddress(null).setForce( + true).setMemberName(pathname).setPort(locatorPort).setWorkingDirectory( + IOUtils.tryGetCanonicalPathElseGetAbsolutePath(workingDirectory)).build(); + + assertNotNull(locatorLauncher); + assertEquals(locatorPort, locatorLauncher.getPort().intValue()); + + try { + // fix for bug 46729 + locatorLauncher.start(); + + final LocatorState locatorState = locatorLauncher.waitOnStatusResponse(60, 10, TimeUnit.SECONDS); + + assertNotNull(locatorState); + assertEquals(Status.ONLINE, locatorState.getStatus()); + + final Result result = connectToLocator(locatorPort); + + assertNotNull(result); + assertEquals(Result.Status.OK, result.getStatus()); + } finally { + assertEquals(Status.STOPPED, locatorLauncher.stop().getStatus()); + assertEquals(Status.NOT_RESPONDING, locatorLauncher.status().getStatus()); + } + } + + public void testEchoWithVariableAtEnd() { + Gfsh gfshInstance = Gfsh.getCurrentInstance(); + + if (gfshInstance == null) { + fail("In testEcho command gfshInstance is null"); + } + getLogWriter().info("Gsh " + gfshInstance); + + gfshInstance.setEnvProperty("TESTSYS", "SYS_VALUE"); + printAllEnvs(gfshInstance); + + String command = "echo --string=\"Hello World! This is ${TESTSYS}\""; + CommandResult cmdResult = executeCommand(command); + printCommandOutput(cmdResult); + + if (cmdResult != null) { + assertEquals(Result.Status.OK, cmdResult.getStatus()); + String stringResult = commandResultToString(cmdResult); + assertEquals("Hello World! This is SYS_VALUE", StringUtils.trim(stringResult)); + } else { + fail("testEchoWithVariableAtEnd failed"); + } + } + + public void testEchoWithNoVariable() { + Gfsh gfshInstance = Gfsh.getCurrentInstance(); + + if (gfshInstance == null) { + fail("In testEcho command gfshInstance is null"); + } + + gfshInstance.setEnvProperty("TESTSYS", "SYS_VALUE"); + printAllEnvs(gfshInstance); + + String command = "echo --string=\"Hello World! This is Pivotal\""; + + CommandResult cmdResult = executeCommand(command); + printCommandOutput(cmdResult); + + if (cmdResult != null) { + assertEquals(Result.Status.OK, cmdResult.getStatus()); + String stringResult = commandResultToString(cmdResult); + assertTrue(stringResult.contains("Hello World! This is Pivotal")); + } else { + fail("testEchoWithNoVariable failed"); + } + } + + public void testEchoWithVariableAtStart() { + Gfsh gfshInstance = Gfsh.getCurrentInstance(); + + if (gfshInstance == null) { + fail("In testEcho command gfshInstance is null"); + } + + gfshInstance.setEnvProperty("TESTSYS", "SYS_VALUE"); + printAllEnvs(gfshInstance); + + String command = "echo --string=\"${TESTSYS} Hello World! This is Pivotal\""; + CommandResult cmdResult = executeCommand(command); + printCommandOutput(cmdResult); + + if (cmdResult != null) { + assertEquals(Result.Status.OK, cmdResult.getStatus()); + String stringResult = commandResultToString(cmdResult); + assertTrue(stringResult.contains("SYS_VALUE Hello World! This is Pivotal")); + } else { + fail("testEchoWithVariableAtStart failed"); + } + } + + public void testEchoWithMultipleVariables() { + Gfsh gfshInstance = Gfsh.getCurrentInstance(); + + if (gfshInstance == null) { + fail("In testEcho command gfshInstance is null"); + } + + gfshInstance.setEnvProperty("TESTSYS", "SYS_VALUE"); + printAllEnvs(gfshInstance); + + String command = "echo --string=\"${TESTSYS} Hello World! This is Pivotal ${TESTSYS}\""; + CommandResult cmdResult = executeCommand(command); + printCommandOutput(cmdResult); + + if (cmdResult != null) { + assertEquals(Result.Status.OK, cmdResult.getStatus()); + String stringResult = commandResultToString(cmdResult); + assertTrue(stringResult.contains("SYS_VALUE Hello World! This is Pivotal SYS_VALUE")); + } else { + fail("testEchoWithMultipleVariables failed"); + } + } + + public void testEchoAllPropertyVariables() { + Gfsh gfshInstance = Gfsh.getCurrentInstance(); + + if (gfshInstance == null) { + fail("In testEcho command gfshInstance is null"); + } + + String command = "echo --string=\"$*\""; + CommandResult cmdResult = executeCommand(command); + printCommandOutput(cmdResult); + + if (cmdResult != null) { + assertEquals(Result.Status.OK, cmdResult.getStatus()); + } else { + fail("testEchoAllPropertyVariables failed"); + } + } + + public void testEchoForSingleVariable() { + Gfsh gfshInstance = Gfsh.getCurrentInstance(); + + if (gfshInstance == null) { + fail("In testEcho command gfshInstance is null"); + } + + gfshInstance.setEnvProperty("TESTSYS", "SYS_VALUE"); + printAllEnvs(gfshInstance); + + String command = "echo --string=${TESTSYS}"; + CommandResult cmdResult = executeCommand(command); + printCommandOutput(cmdResult); + + + if (cmdResult != null) { + assertEquals(Result.Status.OK, cmdResult.getStatus()); + String stringResult = commandResultToString(cmdResult); + assertTrue(stringResult.contains("SYS_VALUE")); + } else { + fail("testEchoForSingleVariable failed"); + } + } + + public void testEchoForSingleVariable2() { + Gfsh gfshInstance = Gfsh.getCurrentInstance(); + + if (gfshInstance == null) { + fail("In testEcho command gfshInstance is null"); + } + + gfshInstance.setEnvProperty("TESTSYS", "SYS_VALUE"); + printAllEnvs(gfshInstance); + + String command = "echo --string=\"${TESTSYS} ${TESTSYS}\""; + CommandResult cmdResult = executeCommand(command); + printCommandOutput(cmdResult); + + if (cmdResult != null) { + assertEquals(Result.Status.OK, cmdResult.getStatus()); + String stringResult = commandResultToString(cmdResult); + assertTrue(stringResult.contains("SYS_VALUE")); + } else { + fail("testEchoForSingleVariable2 failed"); + } + } + + public void testDebug() { + Gfsh gfshInstance = Gfsh.getCurrentInstance(); + + if (gfshInstance == null) { + fail("In testDebug command gfshInstance is null"); + } + + gfshInstance.setDebug(false); + String command = "debug --state=ON"; + CommandResult cmdResult = executeCommand(command); + printCommandOutput(cmdResult); + + if (cmdResult != null) { + assertEquals(Result.Status.OK, cmdResult.getStatus()); + } else { + fail("testDebug failed"); + } + assertEquals(gfshInstance.getDebug(), true); + + } + + public void testHistory() { + Gfsh gfshInstance = Gfsh.getCurrentInstance(); + + if (gfshInstance == null) { + fail("In testHistory command gfshInstance is null"); + } + + gfshInstance.setDebug(false); + String command = "history"; + CommandResult cmdResult = executeCommand(command); + printCommandOutput(cmdResult); + + if (cmdResult != null) { + assertEquals(Result.Status.OK, cmdResult.getStatus()); + } else { + fail("testHistory failed"); + } + } + + public void testHistoryWithFileName() { + Gfsh gfshInstance = Gfsh.getCurrentInstance(); + + if (gfshInstance == null) { + fail("In testHistory command gfshInstance is null"); + } + + String historyFileName = gfshInstance.getGfshConfig().getHistoryFileName(); + File historyFile = new File(historyFileName); + String fileName = historyFile.getParent(); + fileName = fileName + File.separator + getClass().getSimpleName() + "_" + getName() + "-exported.history"; + + String command = "history --file=" + fileName; + CommandResult cmdResult = executeCommand(command); + printCommandOutput(cmdResult); + + if (cmdResult != null) { + assertEquals(Result.Status.OK, cmdResult.getStatus()); + } else { + fail("testHistory failed"); + } + } + + public void testClearHistory() { + Gfsh gfshInstance = Gfsh.getCurrentInstance(); + + if (gfshInstance == null) { + fail("In testClearHistory command gfshInstance is null"); + } + + gfshInstance.setDebug(false); + String command = "history --clear"; + CommandResult cmdResult = executeCommand(command); + printCommandOutput(cmdResult); + + if (cmdResult != null) { + assertEquals(Result.Status.OK, cmdResult.getStatus()); + getLogWriter().info("testClearHistory cmdResult=" + commandResultToString(cmdResult)); + String resultString = commandResultToString(cmdResult); + getLogWriter().info("testClearHistory resultString=" + resultString); + assertTrue(resultString.contains(CliStrings.HISTORY__MSG__CLEARED_HISTORY)); + assertTrue(gfshInstance.getGfshHistory().getHistoryList().size() <= 1); + } else { + fail("testClearHistory failed"); + } + } + + private static void printCommandOutput(CommandResult cmdResult) { + assertNotNull(cmdResult); + getLogWriter().info("Command Output : "); + StringBuilder sb = new StringBuilder(); + cmdResult.resetToFirstLine(); + while (cmdResult.hasNextLine()) { + sb.append(cmdResult.nextLine()).append(DataCommandRequest.NEW_LINE); + } + getLogWriter().info(sb.toString()); + getLogWriter().info(""); + } + + private void printAllEnvs(Gfsh gfsh) { + getLogWriter().info("printAllEnvs : " + StringUtils.objectToString(gfsh.getEnv(), false, 0)); + /* + getLogWriter().info("Gfsh printAllEnvs : " + HydraUtil.ObjectToString(getDefaultShell().getEnv())); + getLogWriter().info("gfsh " + gfsh + " default shell " + getDefaultShell());*/ + } +} http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/eddef322/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/commands/ShowDeadlockDUnitTest.java ---------------------------------------------------------------------- diff --git a/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/commands/ShowDeadlockDUnitTest.java b/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/commands/ShowDeadlockDUnitTest.java new file mode 100644 index 0000000..2d67129 --- /dev/null +++ b/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/commands/ShowDeadlockDUnitTest.java @@ -0,0 +1,271 @@ +/* + * 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 com.gemstone.gemfire.management.internal.cli.commands; + +import com.gemstone.gemfire.cache.Cache; +import com.gemstone.gemfire.cache.execute.Function; +import com.gemstone.gemfire.cache.execute.FunctionContext; +import com.gemstone.gemfire.cache.execute.FunctionService; +import com.gemstone.gemfire.cache.execute.ResultCollector; +import com.gemstone.gemfire.cache30.CacheTestCase; +import com.gemstone.gemfire.distributed.DistributedLockService; +import com.gemstone.gemfire.distributed.internal.DistributionConfig; +import com.gemstone.gemfire.distributed.internal.deadlock.GemFireDeadlockDetector; +import com.gemstone.gemfire.distributed.internal.membership.InternalDistributedMember; +import com.gemstone.gemfire.management.cli.Result; +import com.gemstone.gemfire.management.cli.Result.Status; +import com.gemstone.gemfire.management.internal.cli.CliUtil; +import com.gemstone.gemfire.management.internal.cli.i18n.CliStrings; +import com.gemstone.gemfire.management.internal.cli.remote.CommandProcessor; +import com.gemstone.gemfire.management.internal.cli.util.CommandStringBuilder; +import dunit.Host; +import dunit.SerializableCallable; +import dunit.SerializableRunnable; +import dunit.VM; + +import java.io.File; +import java.io.IOException; +import java.util.Collections; +import java.util.HashSet; +import java.util.Map; +import java.util.Properties; +import java.util.Set; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReentrantLock; + +/** + * This DUnit tests uses same code as GemFireDeadlockDetectorDUnitTest and uses the command processor for executing the + * "show deadlock" command + */ +public class ShowDeadlockDUnitTest extends CacheTestCase { + + /** + * + */ + private static final long serialVersionUID = 1L; + private static final Set<Thread> stuckThreads = Collections.synchronizedSet(new HashSet<Thread>()); + private static final Map<String, String> EMPTY_ENV = Collections.emptyMap(); + + @Override + public void setUp() throws Exception { + super.setUp(); + // This test does not require an actual Gfsh connection to work, however when run as part of a suite, prior tests + // may mess up the environment causing this test to fail. Setting this prevents false failures. + CliUtil.isGfshVM = false; + } + + @Override + public void tearDown2() throws Exception { + invokeInEveryVM(new SerializableRunnable() { + private static final long serialVersionUID = 1L; + + public void run() { + for (Thread thread : stuckThreads) { + thread.interrupt(); + } + } + }); + CliUtil.isGfshVM = true; + } + + public ShowDeadlockDUnitTest(String name) { + super(name); + } + + public void testNoDeadlock() throws ClassNotFoundException, IOException { + Host host = Host.getHost(0); + VM vm0 = host.getVM(0); + VM vm1 = host.getVM(1); + + //Make sure a deadlock from a previous test is cleared. + disconnectAllFromDS(); + + createCache(vm0); + createCache(vm1); + createCache(new Properties()); + + String fileName = "dependency.txt"; + GemFireDeadlockDetector detect = new GemFireDeadlockDetector(); + assertEquals(null, detect.find().findCycle()); + + CommandProcessor commandProcessor = new CommandProcessor(); + CommandStringBuilder csb = new CommandStringBuilder(CliStrings.SHOW_DEADLOCK); + csb.addOption(CliStrings.SHOW_DEADLOCK__DEPENDENCIES__FILE, fileName); + Result result = commandProcessor.createCommandStatement(csb.toString(), EMPTY_ENV).process(); + + String deadLockOutputFromCommand = getResultAsString(result); + + getLogWriter().info("output = " + deadLockOutputFromCommand); + assertEquals(true, result.hasIncomingFiles()); + assertEquals(true, result.getStatus().equals(Status.OK)); + assertEquals(true, deadLockOutputFromCommand.startsWith(CliStrings.SHOW_DEADLOCK__NO__DEADLOCK)); + result.saveIncomingFiles(null); + File file = new File(fileName); + assertTrue(file.exists()); + file.delete(); + + disconnectAllFromDS(); + } + + private static final Lock lock = new ReentrantLock(); + + + public void testDistributedDeadlockWithFunction() throws InterruptedException, ClassNotFoundException, IOException { + Host host = Host.getHost(0); + VM vm0 = host.getVM(0); + VM vm1 = host.getVM(1); + String filename = "gfeDependency.txt"; + InternalDistributedMember member1 = createCache(vm0); + final InternalDistributedMember member2 = createCache(vm1); + createCache(new Properties()); + //Have two threads lock locks on different members in different orders. + //This thread locks the lock member1 first, then member2. + lockTheLocks(vm0, member2); + //This thread locks the lock member2 first, then member1. + lockTheLocks(vm1, member1); + + Thread.sleep(5000); + CommandProcessor commandProcessor = new CommandProcessor(); + CommandStringBuilder csb = new CommandStringBuilder(CliStrings.SHOW_DEADLOCK); + csb.addOption(CliStrings.SHOW_DEADLOCK__DEPENDENCIES__FILE, filename); + Result result = commandProcessor.createCommandStatement(csb.toString(), EMPTY_ENV).process(); + + String deadLockOutputFromCommand = getResultAsString(result); + getLogWriter().info("Deadlock = " + deadLockOutputFromCommand); + result.saveIncomingFiles(null); + assertEquals(true, deadLockOutputFromCommand.startsWith(CliStrings.SHOW_DEADLOCK__DEADLOCK__DETECTED)); + assertEquals(true, result.getStatus().equals(Status.OK)); + File file = new File(filename); + assertTrue(file.exists()); + file.delete(); + + } + + + private void createCache(Properties props) { + getSystem(props); + final Cache cache = getCache(); + } + + private Properties createProperties(Host host, int locatorPort) { + Properties props = new Properties(); + props.setProperty(DistributionConfig.MCAST_PORT_NAME, "0"); +// props.setProperty(DistributionConfig.LOCATORS_NAME, getServerHostName(host) + "[" + locatorPort + "]"); + props.setProperty(DistributionConfig.LOG_LEVEL_NAME, "info"); + props.setProperty(DistributionConfig.STATISTIC_SAMPLING_ENABLED_NAME, "true"); + props.setProperty(DistributionConfig.ENABLE_TIME_STATISTICS_NAME, "true"); + props.put(DistributionConfig.ENABLE_NETWORK_PARTITION_DETECTION_NAME, "true"); + return props; + } + + private void lockTheLocks(VM vm0, final InternalDistributedMember member) { + vm0.invokeAsync(new SerializableRunnable() { + + private static final long serialVersionUID = 1L; + + public void run() { + lock.lock(); + try { + Thread.sleep(1000); + } catch (InterruptedException e) { + fail("interrupted", e); + } + ResultCollector collector = FunctionService.onMember(system, member).execute(new TestFunction()); + //wait the function to lock the lock on member. + collector.getResult(); + lock.unlock(); + } + }); + } + + private void lockTheDLocks(VM vm, final String first, final String second) { + vm.invokeAsync(new SerializableRunnable() { + + private static final long serialVersionUID = 1L; + + public void run() { + getCache(); + DistributedLockService dls = DistributedLockService.create("deadlock_test", getSystem()); + dls.lock(first, 10 * 1000, -1); + + try { + Thread.sleep(1000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + dls.lock(second, 10 * 1000, -1); + } + }); + } + + private InternalDistributedMember createCache(VM vm) { + return (InternalDistributedMember) vm.invoke(new SerializableCallable() { + /** + * + */ + private static final long serialVersionUID = 1L; + + public Object call() { + getCache(); + return getSystem().getDistributedMember(); + } + }); + } + + private String getResultAsString(Result result) { + StringBuilder sb = new StringBuilder(); + while (result.hasNextLine()) { + sb.append(result.nextLine()); + } + + return sb.toString(); + } + + private static class TestFunction implements Function { + + private static final long serialVersionUID = 1L; + private static final int LOCK_WAIT_TIME = 1000; + + public boolean hasResult() { + return true; + } + + public void execute(FunctionContext context) { + try { + stuckThreads.add(Thread.currentThread()); + lock.tryLock(LOCK_WAIT_TIME, TimeUnit.SECONDS); + } catch (InterruptedException e) { + //ingore + } + context.getResultSender().lastResult(null); + } + + public String getId() { + return getClass().getCanonicalName(); + } + + public boolean optimizeForWrite() { + return false; + } + + public boolean isHA() { + return false; + } + } +} + http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/eddef322/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/commands/ShowMetricsDUnitTest.java ---------------------------------------------------------------------- diff --git a/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/commands/ShowMetricsDUnitTest.java b/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/commands/ShowMetricsDUnitTest.java new file mode 100644 index 0000000..a69c35a --- /dev/null +++ b/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/commands/ShowMetricsDUnitTest.java @@ -0,0 +1,347 @@ +/* + * 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 com.gemstone.gemfire.management.internal.cli.commands; + +import com.gemstone.gemfire.cache.Cache; +import com.gemstone.gemfire.cache.Region; +import com.gemstone.gemfire.cache.RegionFactory; +import com.gemstone.gemfire.cache.RegionShortcut; +import com.gemstone.gemfire.cache.server.CacheServer; +import com.gemstone.gemfire.distributed.DistributedMember; +import com.gemstone.gemfire.distributed.internal.DistributionConfig; +import com.gemstone.gemfire.internal.AvailablePortHelper; +import com.gemstone.gemfire.management.CacheServerMXBean; +import com.gemstone.gemfire.management.DistributedRegionMXBean; +import com.gemstone.gemfire.management.DistributedSystemMXBean; +import com.gemstone.gemfire.management.ManagementService; +import com.gemstone.gemfire.management.MemberMXBean; +import com.gemstone.gemfire.management.RegionMXBean; +import com.gemstone.gemfire.management.cli.Result; +import com.gemstone.gemfire.management.cli.Result.Status; +import com.gemstone.gemfire.management.internal.cli.i18n.CliStrings; +import com.gemstone.gemfire.management.internal.cli.remote.CommandProcessor; +import com.gemstone.gemfire.management.internal.cli.result.CommandResult; +import dunit.Host; +import dunit.SerializableCallable; +import dunit.SerializableRunnable; +import dunit.VM; + +import javax.management.ObjectName; +import java.io.File; +import java.io.IOException; +import java.util.Collections; +import java.util.Properties; + +/**** + * @author bansods + */ +public class ShowMetricsDUnitTest extends CliCommandTestBase { + + private static final long serialVersionUID = 1L; + + public ShowMetricsDUnitTest(String name) { + super(name); + // TODO Auto-generated constructor stub + } + + private void createLocalSetUp() { + Properties localProps = new Properties(); + localProps.setProperty(DistributionConfig.NAME_NAME, "Controller"); + getSystem(localProps); + Cache cache = getCache(); + RegionFactory<Integer, Integer> dataRegionFactory = cache.createRegionFactory(RegionShortcut.REPLICATE); + Region region1 = dataRegionFactory.create("REGION1"); + Region region2 = dataRegionFactory.create("REGION2"); + } + + /* + * tests the default version of "show metrics" + */ + public void testShowMetricsDefault() { + createDefaultSetup(null); + createLocalSetUp(); + final VM vm1 = Host.getHost(0).getVM(1); + final String vm1Name = "VM" + vm1.getPid(); + + vm1.invoke(new SerializableRunnable() { + public void run() { + Properties localProps = new Properties(); + localProps.setProperty(DistributionConfig.NAME_NAME, vm1Name); + getSystem(localProps); + + Cache cache = getCache(); + RegionFactory<Integer, Integer> dataRegionFactory = cache.createRegionFactory(RegionShortcut.REPLICATE); + Region region = dataRegionFactory.create("REGION1"); + } + }); + + SerializableCallable showMetricCmd = new SerializableCallable() { + + @Override + public Object call() throws Exception { + WaitCriterion wc = createMBeanWaitCriterion(1, "", null, 0); + waitForCriterion(wc, 5000, 500, true); + CommandProcessor commandProcessor = new CommandProcessor(); + Result result = commandProcessor.createCommandStatement("show metrics", Collections.EMPTY_MAP).process(); + String resultStr = commandResultToString((CommandResult) result); + getLogWriter().info(resultStr); + assertEquals(resultStr, true, result.getStatus().equals(Status.OK)); + return resultStr; + } + }; + + //Invoke the command in the Manager VM + final VM managerVm = Host.getHost(0).getVM(0); + Object managerResultObj = managerVm.invoke(showMetricCmd); + + String managerResult = (String) managerResultObj; + + getLogWriter().info("#SB Manager"); + getLogWriter().info(managerResult); + } + + public void systemSetUp() { + createDefaultSetup(null); + createLocalSetUp(); + final VM vm1 = Host.getHost(0).getVM(1); + final String vm1Name = "VM" + vm1.getPid(); + + vm1.invoke(new SerializableRunnable() { + public void run() { + Properties localProps = new Properties(); + localProps.setProperty(DistributionConfig.NAME_NAME, vm1Name); + getSystem(localProps); + + Cache cache = getCache(); + RegionFactory<Integer, Integer> dataRegionFactory = cache.createRegionFactory(RegionShortcut.REPLICATE); + Region region = dataRegionFactory.create("REGION1"); + } + }); + } + + public void testShowMetricsRegion() throws InterruptedException { + systemSetUp(); + final String regionName = "REGION1"; + SerializableCallable showMetricCmd = new SerializableCallable() { + + @Override + public Object call() throws Exception { + WaitCriterion wc = createMBeanWaitCriterion(2, regionName, null, 0); + waitForCriterion(wc, 5000, 500, true); + CommandProcessor commandProcessor = new CommandProcessor(); + Result result = commandProcessor.createCommandStatement("show metrics --region=REGION1", + Collections.EMPTY_MAP).process(); + String resultAsString = commandResultToString((CommandResult) result); + assertEquals(resultAsString, true, result.getStatus().equals(Status.OK)); + return resultAsString; + } + }; + + //Invoke the command in the Manager VM + final VM managerVm = Host.getHost(0).getVM(0); + Object managerResultObj = managerVm.invoke(showMetricCmd); + + String managerResult = (String) managerResultObj; + + getLogWriter().info("#SB Manager"); + getLogWriter().info(managerResult); + } + + /*** + * Creates WaitCriterion based on creation of different types of MBeans + * + * @param beanType + * @param regionName + * @param memberName + * @return + */ + private WaitCriterion createMBeanWaitCriterion(final int beanType, final String regionName, + final DistributedMember distributedMember, final int cacheServerPort) { + + WaitCriterion waitCriterion = new WaitCriterion() { + + @Override + public boolean done() { + boolean done = false; + Cache cache = getCache(); + ManagementService mgmtService = ManagementService.getManagementService(cache); + if (beanType == 1) { + DistributedSystemMXBean dsMxBean = mgmtService.getDistributedSystemMXBean(); + if (dsMxBean != null) done = true; + } else if (beanType == 2) { + DistributedRegionMXBean dsRegionMxBean = mgmtService.getDistributedRegionMXBean("/" + regionName); + if (dsRegionMxBean != null) done = true; + } else if (beanType == 3) { + ObjectName memberMBeanName = mgmtService.getMemberMBeanName(distributedMember); + MemberMXBean memberMxBean = mgmtService.getMBeanInstance(memberMBeanName, MemberMXBean.class); + + if (memberMxBean != null) done = true; + } else if (beanType == 4) { + ObjectName regionMBeanName = mgmtService.getRegionMBeanName(distributedMember, "/" + regionName); + RegionMXBean regionMxBean = mgmtService.getMBeanInstance(regionMBeanName, RegionMXBean.class); + + if (regionMxBean != null) done = true; + } else if (beanType == 5) { + ObjectName csMxBeanName = mgmtService.getCacheServerMBeanName(cacheServerPort, distributedMember); + CacheServerMXBean csMxBean = mgmtService.getMBeanInstance(csMxBeanName, CacheServerMXBean.class); + + if (csMxBean != null) { + done = true; + } + } + + return done; + } + + @Override + public String description() { + return "Waiting for the mbean to be created"; + } + }; + + return waitCriterion; + } + + public void testShowMetricsMember() throws ClassNotFoundException, IOException, InterruptedException { + systemSetUp(); + Cache cache = getCache(); + final DistributedMember distributedMember = cache.getDistributedSystem().getDistributedMember(); + final String exportFileName = "memberMetricReport.csv"; + + int ports[] = AvailablePortHelper.getRandomAvailableTCPPorts(1); + CacheServer cs = getCache().addCacheServer(); + cs.setPort(ports[0]); + cs.start(); + final int cacheServerPort = cs.getPort(); + + SerializableCallable showMetricCmd = new SerializableCallable() { + @Override + public Object call() throws Exception { + + WaitCriterion wc = createMBeanWaitCriterion(3, "", distributedMember, 0); + waitForCriterion(wc, 5000, 500, true); + wc = createMBeanWaitCriterion(5, "", distributedMember, cacheServerPort); + waitForCriterion(wc, 10000, 500, true); + + final String command = CliStrings.SHOW_METRICS + " --" + CliStrings.SHOW_METRICS__MEMBER + "=" + distributedMember.getId() + " --" + CliStrings.SHOW_METRICS__CACHESERVER__PORT + "=" + cacheServerPort + " --" + CliStrings.SHOW_METRICS__FILE + "=" + exportFileName; + + CommandProcessor commandProcessor = new CommandProcessor(); + Result result = commandProcessor.createCommandStatement(command, Collections.EMPTY_MAP).process(); + String resultAsString = commandResultToString((CommandResult) result); + assertEquals(resultAsString, true, result.getStatus().equals(Status.OK)); + assertTrue(result.hasIncomingFiles()); + result.saveIncomingFiles(null); + File file = new File(exportFileName); + file.deleteOnExit(); + assertTrue(file.exists()); + file.delete(); + return resultAsString; + + } + }; + + //Invoke the command in the Manager VM + final VM managerVm = Host.getHost(0).getVM(0); + Object managerResultObj = managerVm.invoke(showMetricCmd); + + String managerResult = (String) managerResultObj; + + getLogWriter().info("#SB Manager"); + getLogWriter().info(managerResult); + cs.stop(); + } + + public void testShowMetricsRegionFromMember() throws ClassNotFoundException, IOException, InterruptedException { + systemSetUp(); + Cache cache = getCache(); + final DistributedMember distributedMember = cache.getDistributedSystem().getDistributedMember(); + final String exportFileName = "regionOnAMemberReport.csv"; + final String regionName = "REGION1"; + + SerializableCallable showMetricCmd = new SerializableCallable() { + + @Override + public Object call() throws Exception { + + WaitCriterion wc = createMBeanWaitCriterion(4, regionName, distributedMember, 0); + waitForCriterion(wc, 5000, 500, true); + CommandProcessor commandProcessor = new CommandProcessor(); + Result result = commandProcessor.createCommandStatement( + "show metrics --region=" + regionName + " --member=" + distributedMember.getName() + " --file=" + exportFileName, + Collections.EMPTY_MAP).process(); + String resultAsString = commandResultToString((CommandResult) result); + assertEquals(resultAsString, true, result.getStatus().equals(Status.OK)); + assertTrue(result.hasIncomingFiles()); + result.saveIncomingFiles(null); + File file = new File(exportFileName); + file.deleteOnExit(); + assertTrue(file.exists()); + file.delete(); + return resultAsString; + } + }; + + //Invoke the command in the Manager VM + final VM managerVm = Host.getHost(0).getVM(0); + Object managerResultObj = managerVm.invoke(showMetricCmd); + + String managerResult = (String) managerResultObj; + + getLogWriter().info("#SB Manager"); + getLogWriter().info(managerResult); + } + + public void testShowMetricsRegionFromMemberWithCategories() throws ClassNotFoundException, IOException, InterruptedException { + systemSetUp(); + Cache cache = getCache(); + final DistributedMember distributedMember = cache.getDistributedSystem().getDistributedMember(); + final String exportFileName = "regionOnAMemberReport.csv"; + final String regionName = "REGION1"; + + SerializableCallable showMetricCmd = new SerializableCallable() { + + @Override + public Object call() throws Exception { + + WaitCriterion wc = createMBeanWaitCriterion(4, regionName, distributedMember, 0); + waitForCriterion(wc, 5000, 500, true); + CommandProcessor commandProcessor = new CommandProcessor(); + Result result = commandProcessor.createCommandStatement( + "show metrics --region=" + regionName + " --member=" + distributedMember.getName() + " --file=" + exportFileName + " --categories=region,eviction", + Collections.EMPTY_MAP).process(); + String resultAsString = commandResultToString((CommandResult) result); + assertEquals(resultAsString, true, result.getStatus().equals(Status.OK)); + assertTrue(result.hasIncomingFiles()); + result.saveIncomingFiles(null); + File file = new File(exportFileName); + file.deleteOnExit(); + assertTrue(file.exists()); + file.delete(); + return resultAsString; + } + }; + + //Invoke the command in the Manager VM + final VM managerVm = Host.getHost(0).getVM(0); + Object managerResultObj = managerVm.invoke(showMetricCmd); + + String managerResult = (String) managerResultObj; + + getLogWriter().info("#SB Manager"); + getLogWriter().info(managerResult); + } +} http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/eddef322/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/commands/ShowStackTraceDUnitTest.java ---------------------------------------------------------------------- diff --git a/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/commands/ShowStackTraceDUnitTest.java b/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/commands/ShowStackTraceDUnitTest.java new file mode 100644 index 0000000..d1dc87f --- /dev/null +++ b/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/commands/ShowStackTraceDUnitTest.java @@ -0,0 +1,149 @@ +/* + * 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 com.gemstone.gemfire.management.internal.cli.commands; + +import com.gemstone.gemfire.distributed.internal.DistributionConfig; +import com.gemstone.gemfire.management.cli.Result.Status; +import com.gemstone.gemfire.management.internal.cli.i18n.CliStrings; +import com.gemstone.gemfire.management.internal.cli.result.CommandResult; +import com.gemstone.gemfire.management.internal.cli.util.CommandStringBuilder; +import dunit.Host; +import dunit.SerializableRunnable; +import dunit.VM; + +import java.io.File; +import java.io.IOException; +import java.util.Properties; + +/*** + * DUnit test for 'show stack-trace' command + * + * @author bansods + */ +public class ShowStackTraceDUnitTest extends CliCommandTestBase { + + private static final long serialVersionUID = 1L; + + public ShowStackTraceDUnitTest(String name) { + super(name); + } + + private void createCache(Properties props) { + getSystem(props); + getCache(); + } + + private Properties createProperties(Host host, String name, String groups) { + Properties props = new Properties(); + props.setProperty(DistributionConfig.MCAST_PORT_NAME, "0"); + props.setProperty(DistributionConfig.LOG_LEVEL_NAME, "info"); + props.setProperty(DistributionConfig.STATISTIC_SAMPLING_ENABLED_NAME, "true"); + props.setProperty(DistributionConfig.ENABLE_TIME_STATISTICS_NAME, "true"); + props.setProperty(DistributionConfig.NAME_NAME, name); + props.setProperty(DistributionConfig.GROUPS_NAME, groups); + return props; + } + + /*** + * Sets up a system of 3 peers + */ + private void setupSystem() { + disconnectAllFromDS(); + final Host host = Host.getHost(0); + final VM[] servers = {host.getVM(0), host.getVM(1)}; + + final Properties propsManager = createProperties(host, "Manager", "G1"); + final Properties propsServer2 = createProperties(host, "Server", "G2"); + + createDefaultSetup(propsManager); + + servers[1].invoke(new SerializableRunnable("Create cache for server1") { + public void run() { + createCache(propsServer2); + } + }); + } + + /*** + * Tests the default behavior of the show stack-trace command + * + * @throws ClassNotFoundException + * @throws IOException + */ + public void testExportStacktrace() throws ClassNotFoundException, IOException { + setupSystem(); + + File allStacktracesFile = new File("allStackTraces.txt"); + allStacktracesFile.createNewFile(); + allStacktracesFile.deleteOnExit(); + CommandStringBuilder csb = new CommandStringBuilder(CliStrings.EXPORT_STACKTRACE); + csb.addOption(CliStrings.EXPORT_STACKTRACE__FILE, allStacktracesFile.getCanonicalPath()); + String commandString = csb.toString(); + getLogWriter().info("CommandString : " + commandString); + CommandResult commandResult = executeCommand(commandString); + getLogWriter().info("Output : \n" + commandResultToString(commandResult)); + assertTrue(commandResult.getStatus().equals(Status.OK)); + + File mgrStacktraceFile = new File("managerStacktrace.txt"); + mgrStacktraceFile.createNewFile(); + mgrStacktraceFile.deleteOnExit(); + csb = new CommandStringBuilder(CliStrings.EXPORT_STACKTRACE); + csb.addOption(CliStrings.EXPORT_STACKTRACE__FILE, mgrStacktraceFile.getCanonicalPath()); + csb.addOption(CliStrings.EXPORT_STACKTRACE__MEMBER, "Manager"); + commandString = csb.toString(); + getLogWriter().info("CommandString : " + commandString); + commandResult = executeCommand(commandString); + getLogWriter().info("Output : \n" + commandResultToString(commandResult)); + assertTrue(commandResult.getStatus().equals(Status.OK)); + + File serverStacktraceFile = new File("serverStacktrace.txt"); + serverStacktraceFile.createNewFile(); + serverStacktraceFile.deleteOnExit(); + csb = new CommandStringBuilder(CliStrings.EXPORT_STACKTRACE); + csb.addOption(CliStrings.EXPORT_STACKTRACE__FILE, serverStacktraceFile.getCanonicalPath()); + csb.addOption(CliStrings.EXPORT_STACKTRACE__MEMBER, "Server"); + commandString = csb.toString(); + getLogWriter().info("CommandString : " + commandString); + commandResult = executeCommand(commandString); + getLogWriter().info("Output : \n" + commandResultToString(commandResult)); + assertTrue(commandResult.getStatus().equals(Status.OK)); + + File groupStacktraceFile = new File("groupstacktrace.txt"); + groupStacktraceFile.createNewFile(); + groupStacktraceFile.deleteOnExit(); + csb = new CommandStringBuilder(CliStrings.EXPORT_STACKTRACE); + csb.addOption(CliStrings.EXPORT_STACKTRACE__FILE, groupStacktraceFile.getCanonicalPath()); + csb.addOption(CliStrings.EXPORT_STACKTRACE__GROUP, "G2"); + commandString = csb.toString(); + getLogWriter().info("CommandString : " + commandString); + commandResult = executeCommand(commandString); + getLogWriter().info("Output : \n" + commandResultToString(commandResult)); + assertTrue(commandResult.getStatus().equals(Status.OK)); + + File wrongStackTraceFile = new File("wrongStackTrace.txt"); + wrongStackTraceFile.createNewFile(); + wrongStackTraceFile.deleteOnExit(); + csb = new CommandStringBuilder(CliStrings.EXPORT_STACKTRACE); + csb.addOption(CliStrings.EXPORT_STACKTRACE__FILE, wrongStackTraceFile.getCanonicalPath()); + csb.addOption(CliStrings.EXPORT_STACKTRACE__MEMBER, "WrongMember"); + commandString = csb.toString(); + getLogWriter().info("CommandString : " + commandString); + commandResult = executeCommand(commandString); + getLogWriter().info("Output : \n" + commandResultToString(commandResult)); + assertFalse(commandResult.getStatus().equals(Status.OK)); + } +}
