geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jensde...@apache.org
Subject [8/9] incubator-geode git commit: GEODE-563: Moving gfsh tests from closed
Date Tue, 08 Dec 2015 17:27:00 GMT
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/eddef322/gemfire-assembly/src/test/java/com/gemstone/gemfire/management/internal/configuration/SharedConfigurationEndToEndDUnitTest.java
----------------------------------------------------------------------
diff --git a/gemfire-assembly/src/test/java/com/gemstone/gemfire/management/internal/configuration/SharedConfigurationEndToEndDUnitTest.java b/gemfire-assembly/src/test/java/com/gemstone/gemfire/management/internal/configuration/SharedConfigurationEndToEndDUnitTest.java
new file mode 100644
index 0000000..383012e
--- /dev/null
+++ b/gemfire-assembly/src/test/java/com/gemstone/gemfire/management/internal/configuration/SharedConfigurationEndToEndDUnitTest.java
@@ -0,0 +1,434 @@
+/*=========================================================================
+ * Copyright (c) 2010-2014 Pivotal Software, Inc. All Rights Reserved.
+ * This product is protected by U.S. and international copyright
+ * and intellectual property laws. Pivotal products are covered by
+ * one or more patents listed at http://www.pivotal.io/patents.
+ *=========================================================================
+ */
+package com.gemstone.gemfire.management.internal.configuration;
+
+import com.gemstone.gemfire.cache.Cache;
+import com.gemstone.gemfire.cache.CacheFactory;
+import com.gemstone.gemfire.cache.RegionShortcut;
+import com.gemstone.gemfire.cache.wan.GatewaySender.OrderPolicy;
+import com.gemstone.gemfire.distributed.Locator;
+import com.gemstone.gemfire.distributed.internal.DistributionConfig;
+import com.gemstone.gemfire.distributed.internal.InternalLocator;
+import com.gemstone.gemfire.internal.AvailablePortHelper;
+import com.gemstone.gemfire.internal.ClassBuilder;
+import com.gemstone.gemfire.internal.FileUtil;
+import com.gemstone.gemfire.internal.JarDeployer;
+import com.gemstone.gemfire.internal.admin.remote.ShutdownAllRequest;
+import com.gemstone.gemfire.internal.cache.GemFireCacheImpl;
+import com.gemstone.gemfire.internal.lang.StringUtils;
+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.commands.CliCommandTestBase;
+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.SerializableCallable;
+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.HashSet;
+import java.util.Properties;
+import java.util.Set;
+import java.util.concurrent.ExecutionException;
+
+public class SharedConfigurationEndToEndDUnitTest extends CliCommandTestBase {
+  private static final int TIMEOUT = 10000;
+  private static final int INTERVAL = 500;
+  private static final String REGION1 = "R1";
+  private static final String REGION2 = "R2";
+  private static final String INDEX1 = "ID1";
+  private transient ClassBuilder classBuilder = new ClassBuilder();
+  public static Set<String> serverNames = new HashSet<String>();
+  public static Set<String> jarFileNames = new HashSet<String>();
+
+  public SharedConfigurationEndToEndDUnitTest(String name) {
+    super(name);
+    // TODO Auto-generated constructor stub
+  }
+
+  private static final long serialVersionUID = -2276690105585944041L;
+
+  public Set<String> startServers(HeadlessGfsh gfsh, String locatorString, int numServers, String serverNamePrefix, int startNum) throws ClassNotFoundException, IOException {
+    Set<String> serverNames = new HashSet<String>();
+
+    final int[] serverPorts = AvailablePortHelper.getRandomAvailableTCPPorts(numServers);
+    for (int i=0; i<numServers; i++) {
+      int port = serverPorts[i];
+      String serverName = serverNamePrefix+ Integer.toString(i+startNum) + "-" + port;
+      CommandStringBuilder csb = new CommandStringBuilder(CliStrings.START_SERVER);
+      csb.addOption(CliStrings.START_SERVER__NAME, serverName);
+      csb.addOption(CliStrings.START_SERVER__LOCATORS, locatorString);
+      csb.addOption(CliStrings.START_SERVER__SERVER_PORT, Integer.toString(port));
+      CommandResult cmdResult = executeCommand(gfsh, csb.getCommandString());
+      assertEquals(Status.OK, cmdResult.getStatus());
+    }
+    return serverNames;
+  }
+
+  public void testStartServerAndExecuteCommands() throws InterruptedException, ClassNotFoundException, IOException, ExecutionException {
+    addExpectedException("EntryDestroyedException");
+    Object[] result = setup();
+    final int locatorPort = (Integer) result[0];
+    final String jmxHost = (String) result[1];
+    final int jmxPort = (Integer) result[2];
+    final int httpPort = (Integer) result[3];
+    final String locatorString = "localHost[" + locatorPort + "]";
+
+    final HeadlessGfsh gfsh = new HeadlessGfsh("gfsh2", 300);
+    assertNotNull(gfsh);
+    shellConnect(jmxHost, jmxPort, httpPort, gfsh);
+
+    serverNames.addAll(startServers(gfsh, locatorString, 2, "Server", 1));
+    doCreateCommands();
+    serverNames.addAll(startServers(gfsh, locatorString, 1, "NewMember", 4));
+    verifyRegionCreateOnAllMembers(REGION1);
+    verifyRegionCreateOnAllMembers(REGION2);
+    verifyIndexCreationOnAllMembers(INDEX1);
+    verifyAsyncEventQueueCreation();
+   
+
+
+    //shutdown everything
+    getLogWriter().info("Shutting down all the members");
+    shutdownAll();
+    deleteSavedJarFiles();
+  }
+
+
+  private void doCreateCommands() {
+    createRegion(REGION1, RegionShortcut.REPLICATE, null);
+    createRegion(REGION2, RegionShortcut.PARTITION, null);
+    createIndex(INDEX1 , "AAPL", REGION1, null);
+    createAndDeployJar("Deploy1.jar");
+    createAsyncEventQueue("q1");
+    final String autoCompact = "true";
+    final String allowForceCompaction = "true";
+    final String compactionThreshold = "50";
+    final String duCritical = "90";
+    final String duWarning = "85";
+    final String maxOplogSize = "1000";
+    final String queueSize = "300";
+    final String timeInterval = "10";
+    final String writeBufferSize="100";
+    final String diskStoreName = "ds1";
+    final String diskDirs = "ds1";
+    
+    createDiskStore(diskStoreName, diskDirs, autoCompact, allowForceCompaction, compactionThreshold, duCritical, duWarning, maxOplogSize, queueSize, timeInterval, writeBufferSize);
+  }
+
+
+  protected void executeAndVerifyCommand(String commandString) {
+    CommandResult cmdResult = executeCommand(commandString);
+    getLogWriter().info("Command Result : \n" + commandResultToString(cmdResult));
+    assertEquals(Status.OK, cmdResult.getStatus());
+    assertFalse(cmdResult.failedToPersist());
+  }
+
+  private void createRegion(String regionName, RegionShortcut regionShortCut, String group) {
+    CommandStringBuilder csb = new CommandStringBuilder(CliStrings.CREATE_REGION);
+    csb.addOption(CliStrings.CREATE_REGION__REGION, regionName);
+    csb.addOption(CliStrings.CREATE_REGION__REGIONSHORTCUT, regionShortCut.name());
+    executeAndVerifyCommand(csb.getCommandString());
+  }
+
+  private void destroyRegion(String regionName) {
+    CommandStringBuilder csb = new CommandStringBuilder(CliStrings.DESTROY_REGION);
+    csb.addOption(CliStrings.DESTROY_REGION__REGION, regionName);
+    executeAndVerifyCommand(csb.getCommandString());
+  }
+
+  private void stopServer(String serverName) {
+    CommandStringBuilder csb = new CommandStringBuilder(CliStrings.STOP_SERVER);
+    csb.addOption(CliStrings.STOP_SERVER__MEMBER, serverName);
+    executeAndVerifyCommand(csb.getCommandString());
+  }
+
+  public void createAsyncEventQueue(String queueName) {
+    String queueCommandsJarName = "testEndToEndSC-QueueCommands.jar";
+    final File jarFile = new File(queueCommandsJarName);
+
+    try {
+      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;}}");
+
+      FileUtils.writeByteArrayToFile(jarFile, jarBytes);
+      CommandStringBuilder csb = new CommandStringBuilder(CliStrings.DEPLOY);
+      csb.addOption(CliStrings.DEPLOY__JAR, queueCommandsJarName);
+      executeAndVerifyCommand(csb.getCommandString());
+
+      csb = new CommandStringBuilder(CliStrings.CREATE_ASYNC_EVENT_QUEUE);
+      csb.addOption(CliStrings.CREATE_ASYNC_EVENT_QUEUE__ID, queueName);
+      csb.addOption(CliStrings.CREATE_ASYNC_EVENT_QUEUE__LISTENER, "com.qcdunit.QueueCommandsDUnitTestListener");
+      csb.addOption(CliStrings.CREATE_ASYNC_EVENT_QUEUE__BATCH_SIZE, "100");
+      csb.addOption(CliStrings.CREATE_ASYNC_EVENT_QUEUE__BATCHTIMEINTERVAL, "200");
+      csb.addOption(CliStrings.CREATE_ASYNC_EVENT_QUEUE__DISPATCHERTHREADS, "4");
+      csb.addOption(CliStrings.CREATE_ASYNC_EVENT_QUEUE__ENABLEBATCHCONFLATION, "true");
+      csb.addOption(CliStrings.CREATE_ASYNC_EVENT_QUEUE__DISKSYNCHRONOUS, "true");
+      csb.addOption(CliStrings.CREATE_ASYNC_EVENT_QUEUE__MAXIMUM_QUEUE_MEMORY, "1000");
+      csb.addOption(CliStrings.CREATE_ASYNC_EVENT_QUEUE__ORDERPOLICY, OrderPolicy.KEY.toString());
+      csb.addOption(CliStrings.CREATE_ASYNC_EVENT_QUEUE__PERSISTENT, "true");
+      csb.addOption(CliStrings.CREATE_ASYNC_EVENT_QUEUE__PARALLEL, "true");
+      
+      executeAndVerifyCommand(csb.getCommandString());
+
+    } catch (IOException e) {
+      e.printStackTrace();
+    } finally {
+      FileUtils.deleteQuietly(jarFile);
+    }
+  }
+  private void createDiskStore(String diskStoreName, 
+      String diskDirs, 
+      String autoCompact, 
+      String allowForceCompaction, 
+      String compactionThreshold, 
+      String duCritical, 
+      String duWarning,
+      String maxOplogSize,
+      String queueSize,
+      String timeInterval,
+      String writeBufferSize) {
+    CommandStringBuilder csb = new CommandStringBuilder(CliStrings.CREATE_DISK_STORE);
+    csb.addOption(CliStrings.CREATE_DISK_STORE__NAME, diskStoreName);
+    csb.addOption(CliStrings.CREATE_DISK_STORE__DIRECTORY_AND_SIZE, diskDirs);
+    csb.addOptionWithValueCheck(CliStrings.CREATE_DISK_STORE__AUTO_COMPACT, autoCompact);
+    csb.addOptionWithValueCheck(CliStrings.CREATE_DISK_STORE__ALLOW_FORCE_COMPACTION, allowForceCompaction);
+    csb.addOptionWithValueCheck(CliStrings.CREATE_DISK_STORE__COMPACTION_THRESHOLD, compactionThreshold);
+    csb.addOptionWithValueCheck(CliStrings.CREATE_DISK_STORE__DISK_USAGE_CRITICAL_PCT, duCritical);
+    csb.addOptionWithValueCheck(CliStrings.CREATE_DISK_STORE__DISK_USAGE_WARNING_PCT, duWarning);
+    csb.addOptionWithValueCheck(CliStrings.CREATE_DISK_STORE__MAX_OPLOG_SIZE, maxOplogSize);
+    csb.addOptionWithValueCheck(CliStrings.CREATE_DISK_STORE__QUEUE_SIZE, queueSize);
+    csb.addOptionWithValueCheck(CliStrings.CREATE_DISK_STORE__TIME_INTERVAL, timeInterval);
+    csb.addOptionWithValueCheck(CliStrings.CREATE_DISK_STORE__WRITE_BUFFER_SIZE, writeBufferSize);
+    executeAndVerifyCommand(csb.getCommandString());
+  }
+  
+  private void destroyDiskStore(String diskStoreName, String group) {
+    CommandStringBuilder csb = new CommandStringBuilder(CliStrings.DESTROY_DISK_STORE);
+    csb.addOption(CliStrings.DESTROY_DISK_STORE__NAME, diskStoreName);
+    csb.addOptionWithValueCheck(CliStrings.DESTROY_DISK_STORE__GROUP, group);
+    executeAndVerifyCommand(csb.toString());
+  }
+  public void createIndex(String indexName, String expression, String regionName, String group) {
+    CommandStringBuilder csb = new CommandStringBuilder(CliStrings.CREATE_INDEX);
+    csb.addOption(CliStrings.CREATE_INDEX__NAME, indexName);
+    csb.addOption(CliStrings.CREATE_INDEX__EXPRESSION, expression);
+    csb.addOption(CliStrings.CREATE_INDEX__REGION, regionName);
+    executeAndVerifyCommand(csb.getCommandString());
+  }
+
+  public void destoyIndex(String indexName, String regionName, String group) {
+    if (StringUtils.isBlank(indexName) && StringUtils.isBlank(regionName) && StringUtils.isBlank(group)) {
+      return;
+    }
+    CommandStringBuilder csb = new CommandStringBuilder(CliStrings.DESTROY_INDEX);
+    if (!StringUtils.isBlank(indexName)) {
+      csb.addOption(CliStrings.DESTROY_INDEX__NAME, indexName);
+    }
+
+    if (!StringUtils.isBlank(regionName)) {
+      csb.addOption(CliStrings.DESTROY_INDEX__REGION, regionName);
+    }
+
+    if (!StringUtils.isBlank(group)) {
+      csb.addOption(CliStrings.DESTROY_INDEX__GROUP, group);
+    }
+    executeAndVerifyCommand(csb.getCommandString());
+  }
+
+  public void createAndDeployJar(String jarName) {
+    File newDeployableJarFile = new File(jarName);
+    try {
+      this.classBuilder.writeJarFromName("ShareConfigClass", newDeployableJarFile);
+      CommandStringBuilder csb = new CommandStringBuilder(CliStrings.DEPLOY);
+      csb.addOption(CliStrings.DEPLOY__JAR, jarName);
+      executeAndVerifyCommand(csb.getCommandString());
+      jarFileNames.add(jarName);
+    } catch (IOException e) {
+      e.printStackTrace();
+    }
+  }
+
+  public void deleteSavedJarFiles() {
+    try {
+      FileUtil.deleteMatching(new File("."), "^" + JarDeployer.JAR_PREFIX + "Deploy1.*#\\d++$");
+      FileUtil.delete(new File("Deploy1.jar"));
+    } catch (IOException ioe) {
+      ioe.printStackTrace();
+    }
+  }
+
+  public Object[] setup() {
+    disconnectAllFromDS();
+    final int [] ports = AvailablePortHelper.getRandomAvailableTCPPorts(3);
+    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] = locator1Port;
+        result[1] = jmxHost;
+        result[2] = jmxPort;
+        result[3] = httpPort;
+        return result;
+      }
+    });
+
+    HeadlessGfsh gfsh = getDefaultShell();
+    String jmxHost = (String)result[1];
+    int jmxPort = (Integer)result[2];
+    int httpPort = (Integer)result[3];
+
+    shellConnect(jmxHost, jmxPort, httpPort, gfsh);
+    // Create a cache in VM 1
+    VM dataMember = Host.getHost(0).getVM(1);
+    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.NAME_NAME, "DataMember");
+        getSystem(localProps);
+        Cache cache = getCache();
+        assertNotNull(cache);
+        return CliUtil.getAllNormalMembers(cache);
+      }
+    });
+    return result;
+  }
+
+  private void shutdownAll() throws IOException {
+    VM locatorAndMgr = Host.getHost(0).getVM(3);
+    locatorAndMgr.invoke(new SerializableCallable() {
+      /**
+       * 
+       */
+      private static final long serialVersionUID = 1L;
+
+      @Override
+      public Object call() throws Exception {
+        GemFireCacheImpl cache = (GemFireCacheImpl)CacheFactory.getAnyInstance();
+        ShutdownAllRequest.send(cache.getDistributedSystem().getDistributionManager(), -1);
+        return null;
+      }
+    });
+
+    locatorAndMgr.invoke(SharedConfigurationDUnitTest.locatorCleanup);
+    //Clean up the directories
+    if (!serverNames.isEmpty()) {
+      for (String serverName : serverNames) {
+        final File serverDir = new File(serverName);
+        FileUtils.cleanDirectory(serverDir);
+        FileUtils.deleteDirectory(serverDir);
+      }
+    }
+    serverNames.clear();
+    serverNames = null;
+  }
+
+  private void verifyRegionCreateOnAllMembers(String regionName) {
+    CommandStringBuilder csb = new CommandStringBuilder(CliStrings.DESCRIBE_REGION);
+    csb.addOption(CliStrings.DESCRIBE_REGION__NAME, regionName);
+    CommandResult cmdResult = executeCommand(csb.getCommandString());
+    String resultAsString = commandResultToString(cmdResult);
+
+    for (String serverName : serverNames) {
+      assertTrue(resultAsString.contains(serverName));
+    }
+  }     
+
+  private void verifyIndexCreationOnAllMembers(String indexName) {
+    CommandStringBuilder csb = new CommandStringBuilder(CliStrings.LIST_INDEX);
+    CommandResult cmdResult = executeCommand(csb.getCommandString());
+    String resultAsString = commandResultToString(cmdResult);
+
+    for (String serverName : serverNames) {
+      assertTrue(resultAsString.contains(serverName));
+    }
+  }
+  
+  private void verifyAsyncEventQueueCreation() {
+    CommandStringBuilder csb = new CommandStringBuilder(CliStrings.LIST_ASYNC_EVENT_QUEUES);
+    CommandResult cmdResult = executeCommand(csb.toString());
+    String resultAsString = commandResultToString(cmdResult);
+    
+    for (String serverName : serverNames) {
+      assertTrue(resultAsString.contains(serverName));
+    }
+  }
+
+}

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/eddef322/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/HeadlessGfsh.java
----------------------------------------------------------------------
diff --git a/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/HeadlessGfsh.java b/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/HeadlessGfsh.java
new file mode 100644
index 0000000..9ca9809
--- /dev/null
+++ b/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/HeadlessGfsh.java
@@ -0,0 +1,376 @@
+/*
+ * 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;
+
+import com.gemstone.gemfire.management.internal.cli.shell.Gfsh;
+import com.gemstone.gemfire.management.internal.cli.shell.GfshConfig;
+import com.gemstone.gemfire.management.internal.cli.shell.jline.GfshUnsupportedTerminal;
+import edu.umd.cs.findbugs.annotations.SuppressWarnings;
+import jline.ConsoleReader;
+import org.springframework.shell.core.ExitShellRequest;
+import org.springframework.shell.event.ShellStatus.Status;
+
+import java.io.BufferedWriter;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileDescriptor;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.io.PrintStream;
+import java.io.PrintWriter;
+import java.io.Writer;
+import java.util.Properties;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+import java.util.logging.Level;
+
+
+/**
+ * This is headless shell which can be used to submit random commands and get command-result It is used for commands
+ * testing but can be used as for anything like programmatically sending commands to operate on GemFire Distributed
+ * systems. TODO : Merge HeadlessGfsh and HeadlessGfshShell TODO : Provide constructor for optionally specifying
+ * GfshConfig to provide logDirectory and logLevel
+ *
+ * @author tushark
+ */
+@SuppressWarnings("rawtypes")
+public class HeadlessGfsh implements ResultHandler {
+
+  public static final String ERROR_RESULT = "_$_ERROR_RESULT";
+
+  private HeadlessGfshShell shell = null;
+  private LinkedBlockingQueue queue = new LinkedBlockingQueue<>();
+  private long timeout = 20;
+  public String outputString = null;
+
+  public HeadlessGfsh(String name, int timeout) throws ClassNotFoundException, IOException {
+    this(name, timeout, null);
+  }
+
+  public HeadlessGfsh(String name, int timeout, Properties envProps) throws ClassNotFoundException, IOException {
+    this.timeout = timeout;
+    System.setProperty("jline.terminal", GfshUnsupportedTerminal.class.getName());
+    this.shell = new HeadlessGfshShell(name, this);
+    this.shell.setEnvProperty(Gfsh.ENV_APP_RESULT_VIEWER, "non-basic");
+
+    if (envProps != null) {
+      for (String key : envProps.stringPropertyNames()) {
+        this.shell.setEnvProperty(key, envProps.getProperty(key));
+      }
+    }
+
+    // This allows us to avoid race conditions during startup - in particular a NPE on the ConsoleReader which is
+    // created in a separate thread during start()
+    CountDownLatch shellStarted = new CountDownLatch(1);
+    this.shell.addShellStatusListener((oldStatus, newStatus) -> {
+      if (newStatus.getStatus() == Status.STARTED) {
+        shellStarted.countDown();
+      }
+    });
+
+    this.shell.start();
+    this.setThreadLocalInstance();
+
+    try {
+      shellStarted.await();
+    } catch (InterruptedException e) {
+      e.printStackTrace(System.out);
+    }
+  }
+
+  public void setThreadLocalInstance() {
+    shell.setThreadLocalInstance();
+  }
+
+  //TODO : Have non-blocking method also where we move executeCommand call to separate thread-pool
+  public boolean executeCommand(String command) {
+    boolean status = false;
+    try {
+      outputString = null;
+      status = shell.executeCommand(command);
+    } catch (Exception e) {
+      outputString = e.getMessage();
+    }
+    return status;
+  }
+
+  int getCommandExecutionStatus() {
+    return shell.getCommandExecutionStatus();
+  }
+
+  @SuppressWarnings("unchecked")
+  @Override
+  public void handleExecutionResult(Object result, String sysout) {
+    queue.add(result);
+    outputString = sysout;
+  }
+
+  public Object getResult() throws InterruptedException {
+    //Dont wait for when some command calls gfsh.stop();
+    if (shell.stopCalledThroughAPI) return null;
+    try {
+      Object result = queue.poll(timeout, TimeUnit.SECONDS);
+      queue.clear();
+      return result;
+    } catch (InterruptedException e) {
+      e.printStackTrace();
+      throw e;
+    }
+  }
+
+  public void clear() {
+    queue.clear();
+    outputString = null;
+  }
+
+  public void clearEvents() {
+    queue.clear();
+    outputString = null;
+  }
+
+  public void terminate() {
+    shell.terminate();
+  }
+
+  public boolean isConnectedAndReady() {
+    return shell.isConnectedAndReady();
+  }
+
+  public String getErrorString() {
+    return shell.errorString;
+  }
+
+  public boolean hasError() {
+    return shell.hasError();
+  }
+
+  public String getError() {
+    return shell.errorString;
+  }
+
+  public static class HeadlessGfshShell extends Gfsh {
+
+    private ResultHandler handler = null;
+    private final Lock lock = new ReentrantLock();
+    private final Condition endOfShell = lock.newCondition();
+    private ByteArrayOutputStream output = null;
+    private String errorString = null;
+    private boolean hasError = false;
+    boolean stopCalledThroughAPI = false;
+
+    protected HeadlessGfshShell(String testName, ResultHandler handler) throws ClassNotFoundException, IOException {
+      super(false, new String[]{}, new HeadlessGfshConfig(testName));
+      this.handler = handler;
+    }
+
+    public void setThreadLocalInstance() {
+      gfshThreadLocal.set(this);
+    }
+
+    protected void handleExecutionResult(Object result) {
+      if (!result.equals(ERROR_RESULT)) {
+        super.handleExecutionResult(result);
+        handler.handleExecutionResult(result, output.toString());
+        output.reset();
+      } else {
+        //signal waiting queue with error condition with empty output
+        output.reset();
+        handler.handleExecutionResult(result, output.toString());
+      }
+    }
+
+    int getCommandExecutionStatus() {
+      return getLastExecutionStatus();
+    }
+
+    public void terminate() {
+      closeShell();
+      stopPromptLoop();
+      stop();
+    }
+
+    public void stop() {
+      stopCalledThroughAPI = true;
+    }
+
+    private void stopPromptLoop() {
+      lock.lock();
+      try {
+        endOfShell.signalAll();
+      } finally {
+        lock.unlock();
+      }
+    }
+
+    public String getErrorString() {
+      return errorString;
+    }
+
+    public boolean hasError() {
+      return hasError;
+    }
+
+    /**
+     * We override this method just to fool runner thread in reading from nothing. It waits for Condition endOfShell
+     * which is signalled when terminate is called. This achieves clean shutdown of runner thread.
+     */
+    @Override
+    public void promptLoop() {
+      lock.lock();
+      try {
+        while (true) {
+          try {
+            endOfShell.await();
+          } catch (InterruptedException e) {
+            //e.printStackTrace();
+          }
+          this.exitShellRequest = ExitShellRequest.NORMAL_EXIT;
+          setShellStatus(Status.SHUTTING_DOWN);
+          break;
+        }
+      } finally {
+        lock.unlock();
+      }
+    }
+
+    private static void setGfshOutErr(PrintStream outToUse) {
+      Gfsh.gfshout = outToUse;
+      Gfsh.gfsherr = outToUse;
+    }
+
+    /**
+     * This prints out error messages when Exceptions occur in shell. Capture it and set error flag=true and send
+     * ERROR_RESULT on the queue to signal thread waiting for CommandResult
+     */
+    @Override
+    public void logWarning(String message, Throwable t) {
+      super.logWarning(message, t);
+      errorString = message;
+      hasError = true;
+      //signal waiting queue with error condition
+      handleExecutionResult(ERROR_RESULT);
+    }
+
+    /**
+     * This prints out error messages when Exceptions occur in shell. Capture it and set error flag=true and send
+     * ERROR_RESULT on the queue to signal thread waiting for CommandResult
+     */
+    @Override
+    public void logSevere(String message, Throwable t) {
+      super.logSevere(message, t);
+      errorString = message;
+      hasError = true;
+      //signal waiting queue with error condition
+      handleExecutionResult(ERROR_RESULT);
+    }
+
+    /**
+     * Setup console-reader to capture Shell output
+     */
+    @Override
+    protected ConsoleReader createConsoleReader() {
+      try {
+        output = new ByteArrayOutputStream(1024 * 10);
+        PrintStream sysout = new PrintStream(output);
+        Writer wrappedOut = new BufferedWriter(new OutputStreamWriter(sysout));
+        setGfshOutErr(sysout);
+        return new ConsoleReader(new FileInputStream(FileDescriptor.in), new PrintWriter(wrappedOut));
+      } catch (IOException e) {
+        throw new RuntimeException(e);
+      }
+    }
+  }
+
+
+  /**
+   * HeadlessGfshConfig for tests. Taken from TestableGfsh
+   */
+  static class HeadlessGfshConfig extends GfshConfig {
+    {
+      // set vm as a gfsh vm
+      CliUtil.isGfshVM = true;
+    }
+
+    private File parentDir;
+    private String fileNamePrefix;
+    private String name;
+    private String generatedHistoryFileName = null;
+
+    public HeadlessGfshConfig(String name) {
+      this.name = name;
+
+      if (isDUnitTest(this.name)) {
+        fileNamePrefix = this.name;
+      } else {
+        fileNamePrefix = "non-hydra-client";
+      }
+
+      parentDir = new File("gfsh_files");
+      parentDir.mkdirs();
+    }
+
+    private static boolean isDUnitTest(String name) {
+      boolean isDUnitTest = false;
+      if (name != null) {
+        String[] split = name.split("_");
+        if (split.length != 0 && split[0].endsWith("DUnitTest")) {
+          isDUnitTest = true;
+        }
+      }
+      return isDUnitTest;
+    }
+
+    @Override
+    public String getLogFilePath() {
+      return new File(parentDir, getFileNamePrefix() + "-gfsh.log").getAbsolutePath();
+    }
+
+    private String getFileNamePrefix() {
+      String timeStamp = new java.sql.Time(System.currentTimeMillis()).toString();
+      timeStamp = timeStamp.replace(':', '_');
+      return fileNamePrefix + "-" + timeStamp;
+    }
+
+    @Override
+    public String getHistoryFileName() {
+      if (generatedHistoryFileName == null) {
+        String fileName = new File(parentDir, (getFileNamePrefix() + "-gfsh.history")).getAbsolutePath();
+        generatedHistoryFileName = fileName;
+        return fileName;
+      } else {
+        return generatedHistoryFileName;
+      }
+    }
+
+    @Override
+    public boolean isTestConfig() {
+      return true;
+    }
+
+    @Override
+    public Level getLogLevel() {
+      // Keep log level fine for tests
+      return Level.FINE;
+    }
+  }
+
+}

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/eddef322/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/HeadlessGfshJUnitTest.java
----------------------------------------------------------------------
diff --git a/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/HeadlessGfshJUnitTest.java b/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/HeadlessGfshJUnitTest.java
new file mode 100644
index 0000000..0807898
--- /dev/null
+++ b/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/HeadlessGfshJUnitTest.java
@@ -0,0 +1,87 @@
+/*
+ * 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;
+
+import com.gemstone.gemfire.cache.CacheFactory;
+import com.gemstone.gemfire.distributed.DistributedSystem;
+import com.gemstone.gemfire.distributed.internal.DistributionConfig;
+import com.gemstone.gemfire.internal.AvailablePort;
+import com.gemstone.gemfire.internal.cache.GemFireCacheImpl;
+import com.gemstone.gemfire.management.internal.MBeanJMXAdapter;
+import com.gemstone.gemfire.test.junit.categories.UnitTest;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+import javax.management.ObjectName;
+import java.io.IOException;
+import java.util.Properties;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * TODO : Add more tests for error-catch, different type of results etc
+ *
+ * @author tushark
+ */
+@Category(UnitTest.class)
+public class HeadlessGfshJUnitTest {
+
+  @SuppressWarnings({"unused", "deprecation", "unused"})
+  @Test
+  public void testHeadlessGfshTest() throws ClassNotFoundException, IOException, InterruptedException {
+    GemFireCacheImpl cache = null;
+    DistributedSystem ds = null;
+    Properties pr = new Properties();
+    pr.put("name", "testHeadlessGfshTest");
+    pr.put(DistributionConfig.JMX_MANAGER_NAME, "true");
+    pr.put(DistributionConfig.JMX_MANAGER_START_NAME, "true");
+    int port = AvailablePort.getRandomAvailablePort(AvailablePort.SOCKET);
+    pr.put(DistributionConfig.JMX_MANAGER_PORT_NAME, String.valueOf(port));
+    pr.put(DistributionConfig.HTTP_SERVICE_PORT_NAME, "0");
+    pr.put(DistributionConfig.MCAST_PORT_NAME, "0");
+
+    ds = DistributedSystem.connect(pr);
+    cache = (GemFireCacheImpl) CacheFactory.create(ds);
+    ObjectName name = MBeanJMXAdapter.getDistributedSystemName();
+
+    HeadlessGfsh gfsh = new HeadlessGfsh("Test", 25);
+    for (int i = 0; i < 5; i++) {
+      gfsh.executeCommand("connect --jmx-manager=localhost[" + port + "]");
+      Object result = gfsh.getResult();
+      assertTrue(gfsh.isConnectedAndReady());
+      assertNotNull(result);
+      gfsh.clear();
+      gfsh.executeCommand("list members");
+      result = gfsh.getResult();
+      assertNotNull(result);
+      gfsh.executeCommand("disconnect");
+      gfsh.getResult();
+    }
+
+    long l1 = System.currentTimeMillis();
+    gfsh.executeCommand("exit");
+    long l2 = System.currentTimeMillis();
+    gfsh.getResult();
+    long l3 = System.currentTimeMillis();
+    System.out.println("L3-l2=" + (l3 - l2) + " Total time= " + (l3 - l1) / 1000);
+    gfsh.terminate();
+    cache.close();
+    ds.disconnect();
+  }
+
+}

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/eddef322/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/ResultHandler.java
----------------------------------------------------------------------
diff --git a/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/ResultHandler.java b/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/ResultHandler.java
new file mode 100644
index 0000000..2b90b60
--- /dev/null
+++ b/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/ResultHandler.java
@@ -0,0 +1,23 @@
+/*
+ * 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;
+
+public interface ResultHandler {
+  
+  void handleExecutionResult(Object result, String sysout);
+
+}

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/eddef322/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/TableBuilderJUnitTest.java
----------------------------------------------------------------------
diff --git a/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/TableBuilderJUnitTest.java b/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/TableBuilderJUnitTest.java
new file mode 100644
index 0000000..e5f1d86
--- /dev/null
+++ b/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/TableBuilderJUnitTest.java
@@ -0,0 +1,183 @@
+/*
+ * 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;
+
+import com.gemstone.gemfire.management.internal.cli.result.TableBuilder;
+import com.gemstone.gemfire.management.internal.cli.result.TableBuilder.Row;
+import com.gemstone.gemfire.management.internal.cli.result.TableBuilder.RowGroup;
+import com.gemstone.gemfire.management.internal.cli.result.TableBuilder.Table;
+import com.gemstone.gemfire.management.internal.cli.result.TableBuilderHelper;
+import com.gemstone.gemfire.management.internal.cli.shell.Gfsh;
+import com.gemstone.gemfire.test.junit.categories.IntegrationTest;
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.junit.rules.TestName;
+
+import java.io.IOException;
+import java.util.Properties;
+import java.util.Random;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/**
+ * TODO: fails when running integrationTest from gradle command-line or in Eclipse on Windows 7
+ * <p>
+ * com.gemstone.gemfire.management.internal.cli.TableBuilderJUnitTest > testBasicScrapping FAILED
+ * java.lang.AssertionError: Expected length < 100 is 101 at org.junit.Assert.fail(Assert.java:88) at
+ * com.gemstone.gemfire.management.internal.cli.TableBuilderJUnitTest.doTableBuilderTestUnit(TableBuilderJUnitTest.java:115)
+ * at com.gemstone.gemfire.management.internal.cli.TableBuilderJUnitTest.testBasicScrapping(TableBuilderJUnitTest.java:134)
+ * <p>
+ * com.gemstone.gemfire.management.internal.cli.TableBuilderJUnitTest > testManyColumns FAILED java.lang.AssertionError:
+ * Expected length < 100 is 101 at org.junit.Assert.fail(Assert.java:88) at com.gemstone.gemfire.management.internal.cli.TableBuilderJUnitTest.doTableBuilderTestUnit(TableBuilderJUnitTest.java:115)
+ * at com.gemstone.gemfire.management.internal.cli.TableBuilderJUnitTest.testManyColumns(TableBuilderJUnitTest.java:155)
+ *
+ * @author tushark
+ */
+@Category(IntegrationTest.class)
+public class TableBuilderJUnitTest {
+
+  @Rule
+  public TestName testName = new TestName();
+
+  private final Table createTable(int rows, int cols, int width, String separator) {
+    Table resultTable = TableBuilder.newTable();
+    resultTable.setTabularResult(true);
+    resultTable.setColumnSeparator(separator);
+
+    resultTable.newBlankRow();
+    resultTable.newRow().newLeftCol("Displaying all fields for member: ");
+    resultTable.newBlankRow();
+    RowGroup rowGroup = resultTable.newRowGroup();
+    Row row = rowGroup.newRow();
+    for (int colIndex = 0; colIndex < cols; colIndex++) {
+      row.newCenterCol("Field" + colIndex);
+    }
+
+    rowGroup.newRowSeparator('-', false);
+
+    int counter = rows;
+    for (int i = 0; i < counter; i++) {
+      row = rowGroup.newRow();
+      for (int k = 0; k < cols; k++) {
+        row.newLeftCol(getString(i, width / cols));
+      }
+    }
+    resultTable.newBlankRow();
+
+    return resultTable;
+  }
+
+  private Object getString(int i, int width) {
+    StringBuilder sb = new StringBuilder();
+    Random random = new Random();
+    int k = 0;
+    double d = random.nextDouble();
+    // .09 probability
+    if (d <= 0.9) {
+      k = random.nextInt(width);
+    } else {
+      k = width / 2 + random.nextInt(width);
+    }
+    random.nextInt(10);
+    for (int j = 0; j < k; j++) {
+      sb.append(i);
+      if (sb.length() > k) break;
+    }
+    return sb.toString();
+  }
+
+  private HeadlessGfsh createShell(Properties props) throws ClassNotFoundException, IOException {
+    String shellId = getClass().getSimpleName() + "_" + testName;
+    HeadlessGfsh shell = new HeadlessGfsh(shellId, 30, props);
+    return shell;
+  }
+
+  private void doTableBuilderTestUnit(int rows, int cols, String sep, boolean shouldTrim,
+      boolean expectTooManyColEx) throws ClassNotFoundException, IOException {
+    int width = Gfsh.getCurrentInstance().getTerminalWidth();
+    Table table = createTable(rows, cols, width, sep);
+    String st = table.buildTable();
+    System.out.println(st);
+
+    String[] array = st.split("\n");
+
+    int line = 0;
+    for (String s : array) {
+      System.out.println("For line " + line++ + " length is " + s.length() + " isWider = " + (s.length() > width));
+
+      if (shouldTrim) {
+        if (s.length() > width) {
+          fail("Expected length < " + width + " is " + s.length());
+        }
+      } else {
+        if (s.length() > 50 && s.length() <= width) {
+          fail("Expected length <= " + width + " is " + s.length());
+        }
+      }
+
+    }
+  }
+
+  /**
+   * Test Variations tablewide separator true false
+   */
+  @Test
+  public void testBasicScraping() throws ClassNotFoundException, IOException {
+    Properties props = new Properties();
+    props.setProperty(Gfsh.ENV_APP_RESULT_VIEWER, Gfsh.DEFAULT_APP_RESULT_VIEWER);
+    createShell(props);
+    assertTrue(TableBuilderHelper.shouldTrimColumns());
+    doTableBuilderTestUnit(15, 4, "|", true, false);
+  }
+
+
+  @Test
+  public void testSeparatorWithMultipleChars() throws ClassNotFoundException, IOException {
+    Properties props = new Properties();
+    props.setProperty(Gfsh.ENV_APP_RESULT_VIEWER, Gfsh.DEFAULT_APP_RESULT_VIEWER);
+    createShell(props);
+    assertTrue(TableBuilderHelper.shouldTrimColumns());
+    doTableBuilderTestUnit(15, 4, " | ", true, false);
+  }
+
+  /**
+   * multiple columns upto 8 : done
+   */
+  @Test
+  @Ignore("Bug 52051")
+  public void testManyColumns() throws ClassNotFoundException, IOException {
+    createShell(null);
+    assertTrue(TableBuilderHelper.shouldTrimColumns());
+    doTableBuilderTestUnit(15, 6, "|", true, true);
+  }
+
+  /**
+   * set gfsh env property result_viewer to basic disable for external reader
+   */
+  //
+  @Test
+  public void testDisableColumnAdjustment() throws ClassNotFoundException, IOException {
+    createShell(null);
+    assertFalse(TableBuilderHelper.shouldTrimColumns());
+    doTableBuilderTestUnit(15, 12, "|", false, 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/CliCommandTestBase.java
----------------------------------------------------------------------
diff --git a/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/commands/CliCommandTestBase.java b/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/commands/CliCommandTestBase.java
new file mode 100644
index 0000000..a0fb8f8
--- /dev/null
+++ b/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/commands/CliCommandTestBase.java
@@ -0,0 +1,560 @@
+/*
+ * 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.cache30.CacheTestCase;
+import com.gemstone.gemfire.distributed.internal.DistributionConfig;
+import com.gemstone.gemfire.internal.AvailablePortHelper;
+import com.gemstone.gemfire.management.ManagementService;
+import com.gemstone.gemfire.management.internal.cli.CommandManager;
+import com.gemstone.gemfire.management.internal.cli.HeadlessGfsh;
+import com.gemstone.gemfire.management.internal.cli.i18n.CliStrings;
+import com.gemstone.gemfire.management.internal.cli.parser.CommandTarget;
+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 dunit.Host;
+import dunit.SerializableCallable;
+import dunit.SerializableRunnable;
+import util.TestException;
+
+import java.io.IOException;
+import java.io.PrintStream;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.util.Map;
+import java.util.Properties;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Base class for all the CLI/gfsh command dunit tests.
+ *
+ * @author Tushar Khairnar
+ * @author Abhishek Chaudhari
+ * @author David Hoots
+ * @author John Blum
+ */
+public class CliCommandTestBase extends CacheTestCase {
+
+  private static final long serialVersionUID = 1L;
+
+  protected static final String USE_HTTP_SYSTEM_PROPERTY = "useHTTP";
+
+  private ManagementService managementService;
+
+  private transient HeadlessGfsh shell;
+
+  private boolean useHttpOnConnect = Boolean.getBoolean("useHTTP");
+
+  private int httpPort;
+  private int jmxPort;
+
+  private String jmxHost;
+
+  public CliCommandTestBase(String name) {
+    super(name);
+  }
+
+  public void setUp() throws Exception {
+    super.setUp();
+  }
+
+  @Override
+  public void tearDown2() throws Exception {
+    destroyDefaultSetup();
+    super.tearDown2();
+  }
+
+  /**
+   * Create all of the components necessary for the default setup. The provided properties will be used when creating
+   * the default cache. This will create GFSH in the controller VM (VM[4]) (no cache) and the manager in VM[0] (with
+   * cache). When adding regions, functions, keys, whatever to your cache for tests, you'll need to use
+   * Host.getHost(0).getVM(0).invoke(new SerializableRunnable() { public void run() { ... } } in order to have this
+   * setup run in the same VM as the manager.
+   * <p>
+   *
+   * @param props the Properties used when creating the cache for this default setup.
+   * @return the default testable GemFire shell.
+   */
+  @SuppressWarnings("serial")
+  protected final HeadlessGfsh createDefaultSetup(final Properties props) {
+    Object[] result = (Object[]) Host.getHost(0).getVM(0).invoke(new SerializableCallable() {
+      public Object call() {
+        final Object[] result = new Object[3];
+        final Properties localProps = (props != null ? props : new Properties());
+
+        try {
+          jmxHost = InetAddress.getLocalHost().getHostName();
+        } catch (UnknownHostException ignore) {
+          jmxHost = "localhost";
+        }
+
+        if (!localProps.containsKey(DistributionConfig.NAME_NAME)) {
+          localProps.setProperty(DistributionConfig.NAME_NAME, "Manager");
+        }
+
+        final int[] ports = AvailablePortHelper.getRandomAvailableTCPPorts(2);
+
+        jmxPort = ports[0];
+        httpPort = ports[1];
+
+        localProps.setProperty(DistributionConfig.JMX_MANAGER_NAME, "true");
+        localProps.setProperty(DistributionConfig.JMX_MANAGER_START_NAME, "true");
+        localProps.setProperty(DistributionConfig.JMX_MANAGER_BIND_ADDRESS_NAME, String.valueOf(jmxHost));
+        localProps.setProperty(DistributionConfig.JMX_MANAGER_PORT_NAME, String.valueOf(jmxPort));
+        localProps.setProperty(DistributionConfig.HTTP_SERVICE_PORT_NAME, String.valueOf(httpPort));
+
+        getSystem(localProps);
+        verifyManagementServiceStarted(getCache());
+
+        result[0] = jmxHost;
+        result[1] = jmxPort;
+        result[2] = httpPort;
+
+        return result;
+      }
+    });
+
+    this.jmxHost = (String) result[0];
+    this.jmxPort = (Integer) result[1];
+    this.httpPort = (Integer) result[2];
+
+    return defaultShellConnect();
+  }
+
+  protected boolean useHTTPByTest() {
+    return false;
+  }
+
+  /**
+   * Destroy all of the components created for the default setup.
+   */
+  @SuppressWarnings("serial")
+  protected final void destroyDefaultSetup() {
+    if (this.shell != null) {
+      executeCommand(shell, "exit");
+      this.shell.terminate();
+      this.shell = null;
+    }
+
+    disconnectAllFromDS();
+
+    Host.getHost(0).getVM(0).invoke(new SerializableRunnable() {
+      public void run() {
+        verifyManagementServiceStopped();
+      }
+    });
+  }
+
+  /**
+   * Start the default management service using the provided Cache.
+   *
+   * @param cache Cache to use when creating the management service
+   */
+  private void verifyManagementServiceStarted(Cache cache) {
+    assert (cache != null);
+
+    this.managementService = ManagementService.getExistingManagementService(cache);
+    assertNotNull(this.managementService);
+    assertTrue(this.managementService.isManager());
+    assertTrue(checkIfCommandsAreLoadedOrNot());
+  }
+
+  public static boolean checkIfCommandsAreLoadedOrNot() {
+    CommandManager manager;
+    try {
+      manager = CommandManager.getInstance();
+      Map<String, CommandTarget> commands = manager.getCommands();
+      Set set = commands.keySet();
+      if (commands.size() < 1) {
+        return false;
+      }
+      return true;
+    } catch (ClassNotFoundException | IOException e) {
+      throw new RuntimeException("Could not load commands", e);
+    }
+  }
+
+  /**
+   * Stop the default management service.
+   */
+  private void verifyManagementServiceStopped() {
+    if (this.managementService != null) {
+      assertFalse(this.managementService.isManager());
+      this.managementService = null;
+    }
+  }
+
+  /**
+   * Connect the default shell to the default JMX server.
+   *
+   * @return The default shell.
+   */
+  private HeadlessGfsh defaultShellConnect() {
+    HeadlessGfsh shell = getDefaultShell();
+    shellConnect(this.jmxHost, this.jmxPort, this.httpPort, shell);
+    return shell;
+  }
+
+  /**
+   * Connect a shell to the JMX server at the given host and port
+   *
+   * @param host    Host of the JMX server
+   * @param jmxPort Port of the JMX server
+   * @param shell   Shell to connect
+   */
+  protected void shellConnect(final String host, final int jmxPort, final int httpPort, HeadlessGfsh shell) {
+    assert (host != null);
+    assert (shell != null);
+
+    final CommandStringBuilder command = new CommandStringBuilder(CliStrings.CONNECT);
+    String endpoint;
+
+    if (useHttpOnConnect) {
+      endpoint = "http://" + host + ":" + httpPort + "/gemfire/v1";
+      command.addOption(CliStrings.CONNECT__USE_HTTP, Boolean.TRUE.toString());
+      command.addOption(CliStrings.CONNECT__URL, endpoint);
+    } else {
+      endpoint = host + "[" + jmxPort + "]";
+      command.addOption(CliStrings.CONNECT__JMX_MANAGER, endpoint);
+    }
+
+    CommandResult result = executeCommand(shell, command.toString());
+
+    if (!shell.isConnectedAndReady()) {
+      throw new TestException(
+          "Connect command failed to connect to manager " + endpoint + " result=" + commandResultToString(result));
+    }
+
+    info("Successfully connected to managing node using " + (useHttpOnConnect ? "HTTP" : "JMX"));
+    assertEquals(true, shell.isConnectedAndReady());
+  }
+
+  /**
+   * Get the default shell (will create one if it doesn't already exist).
+   *
+   * @return The default shell
+   */
+  protected synchronized final HeadlessGfsh getDefaultShell() {
+    if (this.shell == null) {
+      this.shell = createShell();
+    }
+
+    return this.shell;
+  }
+
+  /**
+   * Create a HeadlessGfsh object.
+   *
+   * @return The created shell.
+   */
+  protected HeadlessGfsh createShell() {
+    try {
+      Gfsh.SUPPORT_MUTLIPLESHELL = true;
+      String shellId = getClass().getSimpleName() + "_" + getName();
+      HeadlessGfsh shell = new HeadlessGfsh(shellId, 30);
+      //Added to avoid trimming of the columns
+      info("Started testable shell: " + shell);
+      return shell;
+    } catch (ClassNotFoundException e) {
+      throw new TestException(getStackTrace(e));
+    } catch (IOException e) {
+      throw new TestException(getStackTrace(e));
+    }
+  }
+
+  /**
+   * Execute a command using the default shell and clear the shell events before returning.
+   *
+   * @param command Command to execute
+   * @return The result of the command execution
+   */
+  protected CommandResult executeCommand(String command) {
+    assert (command != null);
+
+    return executeCommand(getDefaultShell(), command);
+  }
+
+  /**
+   * Execute a command in the provided shell and clear the shell events before returning.
+   *
+   * @param shell   Shell in which to execute the command.
+   * @param command Command to execute
+   * @return The result of the command execution
+   */
+  protected CommandResult executeCommand(HeadlessGfsh shell, String command) {
+    assert (shell != null);
+    assert (command != null);
+
+    CommandResult commandResult = executeCommandWithoutClear(shell, command);
+    shell.clearEvents();
+    return commandResult;
+  }
+
+  /**
+   * Execute a command using the default shell. Useful for getting additional information from the shell after the
+   * command has been executed (using getDefaultShell().???). Caller is responsible for calling
+   * getDefaultShell().clearEvents() when done.
+   *
+   * @param command Command to execute
+   * @return The result of the command execution
+   */
+  @SuppressWarnings("unused")
+  protected CommandResult executeCommandWithoutClear(String command) {
+    assert (command != null);
+
+    return executeCommandWithoutClear(getDefaultShell(), command);
+  }
+
+  /**
+   * Execute a command in the provided shell. Useful for getting additional information from the shell after the command
+   * has been executed (using getDefaultShell().???). Caller is responsible for calling getDefaultShell().clearEvents()
+   * when done.
+   *
+   * @param shell   Shell in which to execute the command.
+   * @param command Command to execute
+   * @return The result of the command execution
+   */
+  protected CommandResult executeCommandWithoutClear(HeadlessGfsh shell, String command) {
+    assert (shell != null);
+    assert (command != null);
+
+    try {
+      info("Executing command " + command + " with command Mgr " + CommandManager.getInstance());
+    } catch (ClassNotFoundException cnfex) {
+      throw new TestException(getStackTrace(cnfex));
+    } catch (IOException ioex) {
+      throw new TestException(getStackTrace(ioex));
+    }
+
+    shell.executeCommand(command);
+    if (shell.hasError()) {
+      error("executeCommand completed with error : " + shell.getError());
+    }
+
+    CommandResult result = null;
+    try {
+      result = (CommandResult) shell.getResult();
+    } catch (InterruptedException ex) {
+      error("shell received InterruptedException");
+    }
+
+    if (result != null) {
+      result.resetToFirstLine();
+    }
+
+    return result;
+  }
+
+  /**
+   * Utility method for viewing the results of a command.
+   *
+   * @param commandResult Results to dump
+   * @param printStream   Stream to dump the results to
+   */
+  protected void printResult(final CommandResult commandResult, PrintStream printStream) {
+    assert (commandResult != null);
+    assert (printStream != null);
+
+    commandResult.resetToFirstLine();
+    printStream.print(commandResultToString(commandResult));
+  }
+
+  protected String commandResultToString(final CommandResult commandResult) {
+    assertNotNull(commandResult);
+
+    commandResult.resetToFirstLine();
+
+    StringBuilder buffer = new StringBuilder(commandResult.getHeader());
+
+    while (commandResult.hasNextLine()) {
+      buffer.append(commandResult.nextLine());
+    }
+
+    buffer.append(commandResult.getFooter());
+
+    return buffer.toString();
+  }
+
+  /**
+   * Utility method for finding the CommandResult object in the Map of CommandOutput objects.
+   *
+   * @param commandOutput CommandOutput Map to search
+   * @return The CommandResult object or null if not found.
+   */
+  protected CommandResult extractCommandResult(Map<String, Object> commandOutput) {
+    assert (commandOutput != null);
+
+    for (Object resultObject : commandOutput.values()) {
+      if (resultObject instanceof CommandResult) {
+        CommandResult result = (CommandResult) resultObject;
+        result.resetToFirstLine();
+        return result;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Utility method to determine how many times a string occurs in another string. Note that when looking for matches
+   * substrings of other matches will be counted as a match. For example, looking for "AA" in the string "AAAA" will
+   * result in a return value of 3.
+   *
+   * @param stringToSearch String to search
+   * @param stringToCount  String to look for and count
+   * @return The number of matches.
+   */
+  protected int countMatchesInString(final String stringToSearch, final String stringToCount) {
+    assert (stringToSearch != null);
+    assert (stringToCount != null);
+
+    int length = stringToSearch.length();
+    int count = 0;
+    for (int i = 0; i < length; i++) {
+      if (stringToSearch.substring(i).startsWith(stringToCount)) {
+        count++;
+      }
+    }
+    return count;
+  }
+
+  /**
+   * Determines if a string contains a trimmed line that matches the pattern. So, any single line whose leading and
+   * trailing spaces have been removed which contains a string that exactly matches the given pattern will be considered
+   * a match.
+   *
+   * @param stringToSearch String to search
+   * @param stringPattern  Pattern to search for
+   * @return True if a match is found, false otherwise
+   */
+  protected boolean stringContainsLine(final String stringToSearch, final String stringPattern) {
+    assert (stringToSearch != null);
+    assert (stringPattern != null);
+
+    Pattern pattern = Pattern.compile("^\\s*" + stringPattern + "\\s*$", Pattern.MULTILINE);
+    Matcher matcher = pattern.matcher(stringToSearch);
+    return matcher.find();
+  }
+
+  /**
+   * Counts the number of distinct lines in a String.
+   *
+   * @param stringToSearch  String to search for lines.
+   * @param countBlankLines Whether to count blank lines (true to count)
+   * @return The number of lines found.
+   */
+  protected int countLinesInString(final String stringToSearch, final boolean countBlankLines) {
+    assert (stringToSearch != null);
+
+    int length = stringToSearch.length();
+    int count = 0;
+    char character = 0;
+    boolean foundNonSpaceChar = false;
+
+    for (int i = 0; i < length; i++) {
+      character = stringToSearch.charAt(i);
+      if (character == '\r' && (i + 1) < length && stringToSearch.charAt(i + 1) == '\n') {
+        i++;
+      }
+      if (character == '\n' || character == '\r') {
+        if (countBlankLines) {
+          count++;
+        } else {
+          if (foundNonSpaceChar) {
+            count++;
+          }
+        }
+        foundNonSpaceChar = false;
+      } else if (character != ' ' && character != '\t') {
+        foundNonSpaceChar = true;
+      }
+    }
+
+    // Even if the last line isn't terminated, it still counts as a line
+    if (character != '\n' && character != '\r') {
+      count++;
+    }
+
+    return count;
+  }
+
+  /**
+   * Get a specific line from the string (using \n or \r as a line separator).
+   *
+   * @param stringToSearch String to get the line from
+   * @param lineNumber     Line number to get
+   * @return The line
+   */
+  protected String getLineFromString(final String stringToSearch, final int lineNumber) {
+    assert (stringToSearch != null);
+    assert (lineNumber > 0);
+
+    int length = stringToSearch.length();
+    int count = 0;
+    int startIndex = 0;
+    char character;
+    int endIndex = length;
+
+    for (int i = 0; i < length; i++) {
+      character = stringToSearch.charAt(i);
+      if (character == '\r' && (i + 1) < length && stringToSearch.charAt(i + 1) == '\n') {
+        i++;
+      }
+      if (character == '\n' || character == '\r') {
+        if (lineNumber == 1) {
+          endIndex = i;
+          break;
+        }
+        if (++count == lineNumber - 1) {
+          startIndex = i + 1;
+        } else if (count >= lineNumber) {
+          endIndex = i;
+          break;
+        }
+      }
+    }
+
+    return stringToSearch.substring(startIndex, endIndex);
+  }
+
+  protected static String getStackTrace(Throwable aThrowable) {
+    StringWriter sw = new StringWriter();
+    aThrowable.printStackTrace(new PrintWriter(sw, true));
+    return sw.toString();
+  }
+
+  protected void info(String string) {
+    getLogWriter().info(string);
+  }
+
+  protected void debug(String string) {
+    getLogWriter().fine(string);
+  }
+
+  protected void error(String string) {
+    getLogWriter().error(string);
+  }
+
+  protected void error(String string, Throwable e) {
+    getLogWriter().error(string, e);
+  }
+}

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/eddef322/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/commands/ConfigCommandsDUnitTest.java
----------------------------------------------------------------------
diff --git a/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/commands/ConfigCommandsDUnitTest.java b/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/commands/ConfigCommandsDUnitTest.java
new file mode 100644
index 0000000..81536db
--- /dev/null
+++ b/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/commands/ConfigCommandsDUnitTest.java
@@ -0,0 +1,497 @@
+/*
+ * 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.server.CacheServer;
+import com.gemstone.gemfire.distributed.Locator;
+import com.gemstone.gemfire.distributed.internal.DistributionConfig;
+import com.gemstone.gemfire.distributed.internal.InternalDistributedSystem;
+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.AvailablePortHelper;
+import com.gemstone.gemfire.internal.FileUtil;
+import com.gemstone.gemfire.internal.cache.GemFireCacheImpl;
+import com.gemstone.gemfire.internal.cache.xmlcache.CacheXmlGenerator;
+import com.gemstone.gemfire.internal.logging.LogWriterImpl;
+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 com.gemstone.gemfire.management.internal.cli.util.CommandStringBuilder;
+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.FileReader;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.lang.management.ManagementFactory;
+import java.lang.management.RuntimeMXBean;
+import java.util.Collections;
+import java.util.List;
+import java.util.Properties;
+
+/**
+ * Dunit class for testing GemFire config commands : export config
+ *
+ * @author David Hoots
+ * @author Sourabh Bansod
+ * @since 7.0
+ */
+public class ConfigCommandsDUnitTest extends CliCommandTestBase {
+  private static final long serialVersionUID = 1L;
+
+  File managerConfigFile = new File("Manager-cache.xml");
+  File managerPropsFile = new File("Manager-gf.properties");
+  File vm1ConfigFile = new File("VM1-cache.xml");
+  File vm1PropsFile = new File("VM1-gf.properties");
+  File vm2ConfigFile = new File("VM2-cache.xml");
+  File vm2PropsFile = new File("VM2-gf.properties");
+  File shellConfigFile = new File("Shell-cache.xml");
+  File shellPropsFile = new File("Shell-gf.properties");
+  File subDir = new File("ConfigCommandsDUnitTestSubDir");
+  File subManagerConfigFile = new File(subDir, managerConfigFile.getName());
+
+  public ConfigCommandsDUnitTest(String name) {
+    super(name);
+  }
+
+  public void tearDown2() throws Exception {
+    deleteTestFiles();
+    invokeInEveryVM(new SerializableRunnable() {
+
+      @Override
+      public void run() {
+        try {
+          deleteTestFiles();
+        } catch (IOException e) {
+          fail("error", e);
+        }
+      }
+    });
+    super.tearDown2();
+  }
+
+  public void testDescribeConfig() throws ClassNotFoundException, IOException {
+    createDefaultSetup(null);
+    final String controllerName = "Member2";
+
+    /***
+     * Create properties for the controller VM
+     */
+    final Properties localProps = new Properties();
+    localProps.setProperty(DistributionConfig.MCAST_PORT_NAME, "0");
+    localProps.setProperty(DistributionConfig.LOG_LEVEL_NAME, "info");
+    localProps.setProperty(DistributionConfig.STATISTIC_SAMPLING_ENABLED_NAME, "true");
+    localProps.setProperty(DistributionConfig.ENABLE_TIME_STATISTICS_NAME, "true");
+    localProps.setProperty(DistributionConfig.NAME_NAME, controllerName);
+    localProps.setProperty(DistributionConfig.GROUPS_NAME, "G1");
+    getSystem(localProps);
+    Cache cache = getCache();
+    int ports[] = AvailablePortHelper.getRandomAvailableTCPPorts(1);
+    CacheServer cs = getCache().addCacheServer();
+    cs.setPort(ports[0]);
+    cs.setMaxThreads(10);
+    cs.setMaxConnections(9);
+    cs.start();
+
+    RuntimeMXBean runtimeBean = ManagementFactory.getRuntimeMXBean();
+    List<String> jvmArgs = runtimeBean.getInputArguments();
+
+    getLogWriter().info("#SB Actual JVM Args : ");
+
+    for (String jvmArg : jvmArgs) {
+      getLogWriter().info("#SB JVM " + jvmArg);
+    }
+
+    InternalDistributedSystem system = (InternalDistributedSystem) cache.getDistributedSystem();
+    DistributionConfig config = system.getConfig();
+    config.setArchiveFileSizeLimit(1000);
+
+    String command = CliStrings.DESCRIBE_CONFIG + " --member=" + controllerName;
+    CommandProcessor cmdProcessor = new CommandProcessor();
+    cmdProcessor.createCommandStatement(command, Collections.EMPTY_MAP).process();
+
+    CommandResult cmdResult = executeCommand(command);
+
+    String resultStr = commandResultToString(cmdResult);
+    getLogWriter().info("#SB Hiding the defaults\n" + resultStr);
+
+    assertEquals(true, cmdResult.getStatus().equals(Status.OK));
+    assertEquals(true, resultStr.contains("G1"));
+    assertEquals(true, resultStr.contains(controllerName));
+    assertEquals(true, resultStr.contains("archive-file-size-limit"));
+    assertEquals(true, !resultStr.contains("copy-on-read"));
+
+    cmdResult = executeCommand(command + " --" + CliStrings.DESCRIBE_CONFIG__HIDE__DEFAULTS + "=false");
+    resultStr = commandResultToString(cmdResult);
+    getLogWriter().info("#SB No hiding of defaults\n" + resultStr);
+
+    assertEquals(true, cmdResult.getStatus().equals(Status.OK));
+    assertEquals(true, resultStr.contains("is-server"));
+    assertEquals(true, resultStr.contains(controllerName));
+    assertEquals(true, resultStr.contains("copy-on-read"));
+
+    cs.stop();
+  }
+
+  @SuppressWarnings("serial")
+  public void testExportConfig() throws IOException {
+    Properties localProps = new Properties();
+    localProps.setProperty(DistributionConfig.NAME_NAME, "Manager");
+    localProps.setProperty(DistributionConfig.GROUPS_NAME, "Group1");
+    createDefaultSetup(localProps);
+
+    // Create a cache in another VM (VM1)
+    Host.getHost(0).getVM(1).invoke(new SerializableRunnable() {
+      public void run() {
+        Properties localProps = new Properties();
+        localProps.setProperty(DistributionConfig.NAME_NAME, "VM1");
+        localProps.setProperty(DistributionConfig.GROUPS_NAME, "Group2");
+        getSystem(localProps);
+        getCache();
+      }
+    });
+
+    // Create a cache in a 3rd VM (VM2)
+    Host.getHost(0).getVM(2).invoke(new SerializableRunnable() {
+      public void run() {
+        Properties localProps = new Properties();
+        localProps.setProperty(DistributionConfig.NAME_NAME, "VM2");
+        localProps.setProperty(DistributionConfig.GROUPS_NAME, "Group2");
+        getSystem(localProps);
+        getCache();
+      }
+    });
+
+    // Create a cache in the local VM
+    localProps = new Properties();
+    localProps.setProperty(DistributionConfig.NAME_NAME, "Shell");
+    getSystem(localProps);
+    Cache cache = getCache();
+
+    // Test export config for all members
+    deleteTestFiles();
+    CommandResult cmdResult = executeCommand("export config");
+    assertEquals(Result.Status.OK, cmdResult.getStatus());
+
+    assertTrue(this.managerConfigFile.exists());
+    assertTrue(this.managerPropsFile.exists());
+    assertTrue(this.vm1ConfigFile.exists());
+    assertTrue(this.vm1PropsFile.exists());
+    assertTrue(this.vm2ConfigFile.exists());
+    assertTrue(this.vm2PropsFile.exists());
+    assertTrue(this.shellConfigFile.exists());
+    assertTrue(this.shellPropsFile.exists());
+
+    // Test exporting member
+    deleteTestFiles();
+    cmdResult = executeCommand("export config --member=Manager");
+    assertEquals(Result.Status.OK, cmdResult.getStatus());
+
+    assertTrue(this.managerConfigFile.exists());
+    assertFalse(this.vm1ConfigFile.exists());
+    assertFalse(this.vm2ConfigFile.exists());
+    assertFalse(this.shellConfigFile.exists());
+
+    // Test exporting group
+    deleteTestFiles();
+    cmdResult = executeCommand("export config --group=Group2");
+    assertEquals(Result.Status.OK, cmdResult.getStatus());
+
+    assertFalse(this.managerConfigFile.exists());
+    assertTrue(this.vm1ConfigFile.exists());
+    assertTrue(this.vm2ConfigFile.exists());
+    assertFalse(this.shellConfigFile.exists());
+
+    // Test export to directory
+    deleteTestFiles();
+    cmdResult = executeCommand("export config --dir=" + subDir.getAbsolutePath());
+    assertEquals(Result.Status.OK, cmdResult.getStatus());
+
+    assertFalse(this.managerConfigFile.exists());
+    assertTrue(this.subManagerConfigFile.exists());
+
+    // Test the contents of the file
+    StringWriter stringWriter = new StringWriter();
+    PrintWriter printWriter = new PrintWriter(stringWriter);
+    CacheXmlGenerator.generate(cache, printWriter, false, false, false);
+    String configToMatch = stringWriter.toString();
+
+    deleteTestFiles();
+    cmdResult = executeCommand("export config --member=Shell");
+    assertEquals(Result.Status.OK, cmdResult.getStatus());
+
+    char[] fileContents = new char[configToMatch.length()];
+    try {
+      FileReader reader = new FileReader(shellConfigFile);
+      reader.read(fileContents);
+    } catch (Exception ex) {
+      fail("Unable to read file contents for comparison", ex);
+    }
+
+    assertEquals(configToMatch, new String(fileContents));
+  }
+
+  public void testAlterRuntimeConfig() throws ClassNotFoundException, IOException {
+    final String controller = "controller";
+    createDefaultSetup(null);
+    Properties localProps = new Properties();
+    localProps.setProperty(DistributionConfig.NAME_NAME, controller);
+    localProps.setProperty(DistributionConfig.LOG_LEVEL_NAME, "error");
+    getSystem(localProps);
+    final GemFireCacheImpl cache = (GemFireCacheImpl) getCache();
+    final DistributionConfig config = cache.getSystem().getConfig();
+    CommandStringBuilder csb = new CommandStringBuilder(CliStrings.ALTER_RUNTIME_CONFIG);
+    csb.addOption(CliStrings.ALTER_RUNTIME_CONFIG__MEMBER, controller);
+    csb.addOption(CliStrings.ALTER_RUNTIME_CONFIG__LOG__LEVEL, "info");
+    csb.addOption(CliStrings.ALTER_RUNTIME_CONFIG__LOG__FILE__SIZE__LIMIT, "50");
+    csb.addOption(CliStrings.ALTER_RUNTIME_CONFIG__ARCHIVE__DISK__SPACE__LIMIT, "32");
+    csb.addOption(CliStrings.ALTER_RUNTIME_CONFIG__ARCHIVE__FILE__SIZE__LIMIT, "49");
+    csb.addOption(CliStrings.ALTER_RUNTIME_CONFIG__STATISTIC__SAMPLE__RATE, "2000");
+    csb.addOption(CliStrings.ALTER_RUNTIME_CONFIG__STATISTIC__ARCHIVE__FILE, "stat.gfs");
+    csb.addOption(CliStrings.ALTER_RUNTIME_CONFIG__STATISTIC__SAMPLING__ENABLED, "true");
+    csb.addOption(CliStrings.ALTER_RUNTIME_CONFIG__LOG__DISK__SPACE__LIMIT, "10");
+    CommandResult cmdResult = executeCommand(csb.getCommandString());
+    String resultString = commandResultToString(cmdResult);
+    getLogWriter().info("Result\n");
+    getLogWriter().info(resultString);
+    assertEquals(true, cmdResult.getStatus().equals(Status.OK));
+    assertEquals(LogWriterImpl.INFO_LEVEL, config.getLogLevel());
+    assertEquals(50, config.getLogFileSizeLimit());
+    assertEquals(32, config.getArchiveDiskSpaceLimit());
+    assertEquals(2000, config.getStatisticSampleRate());
+    assertEquals("stat.gfs", config.getStatisticArchiveFile().getName());
+    assertEquals(true, config.getStatisticSamplingEnabled());
+    assertEquals(10, config.getLogDiskSpaceLimit());
+
+
+    CommandProcessor commandProcessor = new CommandProcessor();
+    Result result = commandProcessor.createCommandStatement("alter runtime", Collections.EMPTY_MAP).process();
+  }
+
+  public void testAlterRuntimeConfigRandom() {
+    final String member1 = "VM1";
+    final String controller = "controller";
+    createDefaultSetup(null);
+    Properties localProps = new Properties();
+    localProps.setProperty(DistributionConfig.NAME_NAME, controller);
+    localProps.setProperty(DistributionConfig.LOG_LEVEL_NAME, "error");
+    getSystem(localProps);
+    final GemFireCacheImpl cache = (GemFireCacheImpl) getCache();
+    final DistributionConfig config = cache.getSystem().getConfig();
+
+    Host.getHost(0).getVM(1).invoke(new SerializableRunnable() {
+      public void run() {
+        Properties localProps = new Properties();
+        localProps.setProperty(DistributionConfig.NAME_NAME, member1);
+        getSystem(localProps);
+        Cache cache = getCache();
+      }
+    });
+
+    CommandStringBuilder csb = new CommandStringBuilder(CliStrings.ALTER_RUNTIME_CONFIG);
+    CommandResult cmdResult = executeCommand(csb.getCommandString());
+    String resultAsString = commandResultToString(cmdResult);
+    getLogWriter().info("#SB Result\n");
+    getLogWriter().info(resultAsString);
+    assertEquals(true, cmdResult.getStatus().equals(Status.ERROR));
+    assertTrue(resultAsString.contains(CliStrings.ALTER_RUNTIME_CONFIG__RELEVANT__OPTION__MESSAGE));
+
+    csb = new CommandStringBuilder(CliStrings.ALTER_RUNTIME_CONFIG);
+    csb.addOption(CliStrings.ALTER_RUNTIME_CONFIG__LOG__DISK__SPACE__LIMIT, "2000000000");
+    cmdResult = executeCommand(csb.getCommandString());
+    resultAsString = commandResultToString(cmdResult);
+    getLogWriter().info("#SB Result\n");
+    getLogWriter().info(resultAsString);
+    assertEquals(true, cmdResult.getStatus().equals(Status.ERROR));
+
+  }
+
+  public void testAlterRuntimeConfigOnAllMembers() {
+    final String member1 = "VM1";
+    final String controller = "controller";
+    createDefaultSetup(null);
+    Properties localProps = new Properties();
+    localProps.setProperty(DistributionConfig.NAME_NAME, controller);
+    localProps.setProperty(DistributionConfig.LOG_LEVEL_NAME, "error");
+    getSystem(localProps);
+    final GemFireCacheImpl cache = (GemFireCacheImpl) getCache();
+    final DistributionConfig config = cache.getSystem().getConfig();
+
+    Host.getHost(0).getVM(1).invoke(new SerializableRunnable() {
+      public void run() {
+        Properties localProps = new Properties();
+        localProps.setProperty(DistributionConfig.NAME_NAME, member1);
+        getSystem(localProps);
+        Cache cache = getCache();
+      }
+    });
+    CommandStringBuilder csb = new CommandStringBuilder(CliStrings.ALTER_RUNTIME_CONFIG);
+    csb.addOption(CliStrings.ALTER_RUNTIME_CONFIG__LOG__LEVEL, "info");
+    csb.addOption(CliStrings.ALTER_RUNTIME_CONFIG__LOG__FILE__SIZE__LIMIT, "50");
+    csb.addOption(CliStrings.ALTER_RUNTIME_CONFIG__ARCHIVE__DISK__SPACE__LIMIT, "32");
+    csb.addOption(CliStrings.ALTER_RUNTIME_CONFIG__ARCHIVE__FILE__SIZE__LIMIT, "49");
+    csb.addOption(CliStrings.ALTER_RUNTIME_CONFIG__STATISTIC__SAMPLE__RATE, "2000");
+    csb.addOption(CliStrings.ALTER_RUNTIME_CONFIG__STATISTIC__ARCHIVE__FILE, "stat.gfs");
+    csb.addOption(CliStrings.ALTER_RUNTIME_CONFIG__STATISTIC__SAMPLING__ENABLED, "true");
+    csb.addOption(CliStrings.ALTER_RUNTIME_CONFIG__LOG__DISK__SPACE__LIMIT, "10");
+    CommandResult cmdResult = executeCommand(csb.getCommandString());
+    String resultString = commandResultToString(cmdResult);
+    getLogWriter().info("#SB Result\n");
+    getLogWriter().info(resultString);
+    assertEquals(true, cmdResult.getStatus().equals(Status.OK));
+    assertEquals(LogWriterImpl.INFO_LEVEL, config.getLogLevel());
+    assertEquals(50, config.getLogFileSizeLimit());
+    assertEquals(49, config.getArchiveFileSizeLimit());
+    assertEquals(32, config.getArchiveDiskSpaceLimit());
+    assertEquals(2000, config.getStatisticSampleRate());
+    assertEquals("stat.gfs", config.getStatisticArchiveFile().getName());
+    assertEquals(true, config.getStatisticSamplingEnabled());
+    assertEquals(10, config.getLogDiskSpaceLimit());
+
+    // Validate the changes in the vm1
+    Host.getHost(0).getVM(1).invoke(new SerializableRunnable() {
+      public void run() {
+        GemFireCacheImpl cacheVM1 = (GemFireCacheImpl) getCache();
+        final DistributionConfig configVM1 = cacheVM1.getSystem().getConfig();
+        assertEquals(LogWriterImpl.INFO_LEVEL, configVM1.getLogLevel());
+        assertEquals(50, configVM1.getLogFileSizeLimit());
+        assertEquals(49, configVM1.getArchiveFileSizeLimit());
+        assertEquals(32, configVM1.getArchiveDiskSpaceLimit());
+        assertEquals(2000, configVM1.getStatisticSampleRate());
+        assertEquals("stat.gfs", configVM1.getStatisticArchiveFile().getName());
+        assertEquals(true, configVM1.getStatisticSamplingEnabled());
+        assertEquals(10, configVM1.getLogDiskSpaceLimit());
+      }
+    });
+  }
+
+  /**
+   * Asserts that altering the runtime config correctly updates the shared configuration.
+   * <p>
+   * Disabled: this test frequently fails during unit test runs. See ticket #52204
+   */
+  public void disabledtestAlterUpdatesSharedConfig() {
+    disconnectAllFromDS();
+
+    final String groupName = "testAlterRuntimeConfigSharedConfigGroup";
+
+    // 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.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 SerializableCallable() {
+      @Override
+      public Object call() throws Exception {
+        //Make sure no previous shared config is screwing up this test.
+        FileUtil.delete(new File("ConfigDiskDir_Locator"));
+        FileUtil.delete(new File("cluster_config"));
+        Properties localProps = new Properties();
+        localProps.setProperty(DistributionConfig.MCAST_PORT_NAME, "0");
+        localProps.setProperty(DistributionConfig.LOCATORS_NAME, "localhost:" + locatorPort);
+        localProps.setProperty(DistributionConfig.LOG_LEVEL_NAME, "error");
+        localProps.setProperty(DistributionConfig.GROUPS_NAME, groupName);
+        getSystem(localProps);
+
+        assertNotNull(getCache());
+        assertEquals("error", system.getConfig().getAttribute(DistributionConfig.LOG_LEVEL_NAME));
+        return null;
+      }
+    });
+
+    // Test altering the runtime config
+    CommandStringBuilder commandStringBuilder = new CommandStringBuilder(CliStrings.ALTER_RUNTIME_CONFIG);
+    commandStringBuilder.addOption(CliStrings.ALTER_RUNTIME_CONFIG__GROUP, groupName);
+    commandStringBuilder.addOption(CliStrings.ALTER_RUNTIME_CONFIG__LOG__LEVEL, "fine");
+    CommandResult cmdResult = executeCommand(commandStringBuilder.toString());
+    assertEquals(Result.Status.OK, cmdResult.getStatus());
+
+    // Make sure the shared config was updated
+    Host.getHost(0).getVM(3).invoke(new SerializableRunnable() {
+      @Override
+      public void run() {
+        SharedConfiguration sharedConfig = ((InternalLocator) Locator.getLocator()).getSharedConfiguration();
+        Properties gemfireProperties;
+        try {
+          gemfireProperties = sharedConfig.getConfiguration(groupName).getGemfireProperties();
+          assertEquals("fine", gemfireProperties.get(DistributionConfig.LOG_LEVEL_NAME));
+        } catch (Exception e) {
+          fail("Error occurred in cluster configuration service", e);
+        }
+      }
+    });
+  }
+
+  private final void deleteTestFiles() throws IOException {
+    this.managerConfigFile.delete();
+    this.managerPropsFile.delete();
+    this.vm1ConfigFile.delete();
+    this.vm1PropsFile.delete();
+    this.vm2ConfigFile.delete();
+    this.vm2PropsFile.delete();
+    this.shellConfigFile.delete();
+    this.shellPropsFile.delete();
+
+    FileUtils.deleteDirectory(this.subDir);
+  }
+}


Mime
View raw message