geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From kl...@apache.org
Subject [1/2] incubator-geode git commit: GEODE-127: Improve test reliability and execution speed.
Date Wed, 29 Jul 2015 16:33:44 GMT
Repository: incubator-geode
Updated Branches:
  refs/heads/develop ea8ce3f54 -> 94939c1f9


http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/94939c1f/gemfire-core/src/test/java/com/gemstone/gemfire/test/process/ProcessWrapper.java
----------------------------------------------------------------------
diff --git a/gemfire-core/src/test/java/com/gemstone/gemfire/test/process/ProcessWrapper.java
b/gemfire-core/src/test/java/com/gemstone/gemfire/test/process/ProcessWrapper.java
index 3931b22..5bf2408 100644
--- a/gemfire-core/src/test/java/com/gemstone/gemfire/test/process/ProcessWrapper.java
+++ b/gemfire-core/src/test/java/com/gemstone/gemfire/test/process/ProcessWrapper.java
@@ -1,5 +1,7 @@
 package com.gemstone.gemfire.test.process;
 
+import static org.junit.Assert.*;
+
 import java.io.File;
 import java.io.PrintStream;
 import java.util.ArrayList;
@@ -12,6 +14,7 @@ import java.util.Properties;
 import java.util.concurrent.BlockingQueue;
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.regex.Pattern;
 
@@ -19,28 +22,26 @@ import org.apache.logging.log4j.Logger;
 
 import com.gemstone.gemfire.internal.logging.LogService;
 
-import com.gemstone.gemfire.test.process.*;
-
-import junit.framework.Assert;
-
 /**
- * Wraps spawned process to capture output and provide hooks to the
- * {@link java.lang.Process} object.
+ * Wraps spawned {@link java.lang.Process} to capture output and provide interaction with
the process.
  *
  * @author Kirk Lund
  * @since 4.1.1
  */
-public class ProcessWrapper extends Assert {
+public class ProcessWrapper {
   private static final Logger logger = LogService.getLogger();
 
-  protected static final String TIMEOUT_MILLIS_PROPERTY = "quickstart.test.TIMEOUT_MILLIS";
-  private static final long TIMEOUT_MILLIS = Long.getLong(TIMEOUT_MILLIS_PROPERTY, 5 * 60
* 1000L); 
-  private static final boolean JAVA_AWT_HEADLESS = true;
+  protected static final String TIMEOUT_MILLIS_PROPERTY = "process.test.timeoutMillis";
+  protected static final long TIMEOUT_MILLIS_DEFAULT = 5 * 60 * 1000;
+  private static final long DELAY = 10;
 
-  private final String[] jvmArgs;  
+  private final boolean headless;
+  private final long timeoutMillis; 
+  
+  private final String[] jvmArguments;  
   
   private final Class<?> mainClass;
-  private final String[] mainArgs;
+  private final String[] mainArguments;
 
   private volatile Process process;
   private volatile Throwable processException;
@@ -60,54 +61,45 @@ public class ProcessWrapper extends Assert {
   private ProcessStreamReader stdout;
   private ProcessStreamReader stderr;
   
-  public ProcessWrapper(Class<?> main, String[] mainArgs) {
-    this(main, mainArgs, true);
-  }
-
-  public ProcessWrapper(Class<?> main, String[] mainArgs, boolean useMainLauncher)
{
-    this(null, main, mainArgs, true);
-  }
-  
-  public ProcessWrapper(String[] jvmArgs, Class<?> main, String[] mainArgs, boolean
useMainLauncher) {
-    this.jvmArgs = jvmArgs;
+  private ProcessWrapper(final String[] jvmArguments, final Class<?> mainClass, final
String[] mainArguments, final boolean useMainLauncher, final boolean headless, final long
timeoutMillis) {
+    this.jvmArguments = jvmArguments;
+    this.mainClass = mainClass;
+    this.mainArguments = mainArguments;
+    this.useMainLauncher = useMainLauncher;
+    this.headless = headless;
+    this.timeoutMillis = timeoutMillis;
     
-    this.mainClass = main;
-    this.mainArgs = mainArgs;
-
     this.lineBuffer = new LinkedBlockingQueue<String>();
     this.allLines = Collections.synchronizedList(new ArrayList<String>());
-    
-    this.useMainLauncher = useMainLauncher;
   }
   
-  public ProcessStreamReader getStandardOutReader() { // TODO:protected
+  public ProcessStreamReader getStandardOutReader() {
     synchronized (this.exitValue) {
       return stdout;
     }
   }
   
-  public ProcessStreamReader getStandardErrorReader() { // TODO:protected
+  public ProcessStreamReader getStandardErrorReader() {
     synchronized (this.exitValue) {
       return stderr;
     }
   }
   
-  private void waitForProcessStart() throws InterruptedException {
-    long start = System.currentTimeMillis();
+  private void waitForProcessStart() throws InterruptedException, TimeoutException {
+    final long start = System.currentTimeMillis();
     boolean done = false;
     while (!done) {
       synchronized (this.exitValue) {
-        done = (this.process != null || this.processException != null) && 
-            (this.started || this.exitValue.get() > -1 || this.interrupted);
+        done = (this.process != null || this.processException != null) && (this.started
|| this.exitValue.get() > -1 || this.interrupted);
       }
-      if (!done && System.currentTimeMillis() > start + TIMEOUT_MILLIS) {
-        fail("Timed out launching process");
+      if (!done && System.currentTimeMillis() > start + timeoutMillis) {
+        throw new TimeoutException("Timed out launching process");
       }
-      Thread.sleep(100);
+      Thread.sleep(DELAY);
     }
   }
   
-  public boolean isAlive() throws InterruptedException {
+  public boolean isAlive() throws InterruptedException, TimeoutException {
     checkStarting();
     waitForProcessStart();
     
@@ -126,9 +118,9 @@ public class ProcessWrapper extends Assert {
     return this;
   }
 
-  public int waitFor(long timeout, boolean throwOnTimeout) throws InterruptedException {
+  public int waitFor(final long timeout, final boolean throwOnTimeout) throws InterruptedException
{
     checkStarting();
-    Thread thread = getThread();
+    final Thread thread = getThread();
     thread.join(timeout);
     synchronized (this.exitValue) {
       if (throwOnTimeout) {
@@ -138,29 +130,29 @@ public class ProcessWrapper extends Assert {
     }
   }
   
-  public int waitFor(long timeout) throws InterruptedException {
+  public int waitFor(final long timeout) throws InterruptedException {
     return waitFor(timeout, false);
   }
   
-  public int waitFor(boolean throwOnTimeout) throws InterruptedException {
-    return waitFor(TIMEOUT_MILLIS, throwOnTimeout);
+  public int waitFor(final boolean throwOnTimeout) throws InterruptedException {
+    return waitFor(timeoutMillis, throwOnTimeout);
   }
   
   public int waitFor() throws InterruptedException {
-    return waitFor(TIMEOUT_MILLIS, false);
+    return waitFor(timeoutMillis, false);
   }
   
   public String getOutput() { 
     return getOutput(false);
   }
 
-  public String getOutput(boolean ignoreStopped) { 
+  public String getOutput(final boolean ignoreStopped) { 
     checkStarting();
     if (!ignoreStopped) {
       checkStopped();
     }
-    StringBuffer sb = new StringBuffer();
-    Iterator<String> iterator = allLines.iterator();
+    final StringBuffer sb = new StringBuffer();
+    final Iterator<String> iterator = this.allLines.iterator();
     while (iterator.hasNext()) {
       sb.append(iterator.next() + "\n");
     }
@@ -173,25 +165,24 @@ public class ProcessWrapper extends Assert {
     return this;
   }
 
-  public ProcessWrapper sendInput(String input) {
+  public ProcessWrapper sendInput(final String input) {
     checkStarting();
-    PrintStream ps = new PrintStream(this.process.getOutputStream());
+    final PrintStream ps = new PrintStream(this.process.getOutputStream());
     ps.println(input);
     ps.flush();
     return this;
   }
 
-  public ProcessWrapper failIfOutputMatches(String patternString, long timeoutMillis) throws
InterruptedException {
+  public ProcessWrapper failIfOutputMatches(final String patternString, final long timeoutMillis)
throws InterruptedException {
     checkStarting();
     checkOk();
-
-    Pattern pattern = Pattern.compile(patternString);
     
+    final Pattern pattern = Pattern.compile(patternString);
     logger.debug("failIfOutputMatches waiting for \"{}\"...", patternString);
-    long start = System.currentTimeMillis();
+    final long start = System.currentTimeMillis();
+    
     while(System.currentTimeMillis() <= start+timeoutMillis) {
-      String line = lineBuffer.poll(timeoutMillis, TimeUnit.MILLISECONDS);
-
+      final String line = lineBuffer.poll(timeoutMillis, TimeUnit.MILLISECONDS);
       if (line != null && pattern.matcher(line).matches()) {
         fail("failIfOutputMatches Matched pattern \"" + patternString + "\" against output
\"" + line + "\". Output: " + this.allLines);
       }
@@ -203,18 +194,17 @@ public class ProcessWrapper extends Assert {
    * Waits for the process stdout or stderr stream to contain the specified 
    * text. Uses the specified timeout for debugging purposes.
    */
-  public ProcessWrapper waitForOutputToMatch(String patternString, long timeoutMillis) throws
InterruptedException {
+  public ProcessWrapper waitForOutputToMatch(final String patternString, final long timeoutMillis)
throws InterruptedException {
     checkStarting();
     checkOk();
 
-    Pattern pattern = Pattern.compile(patternString);
-    
+    final Pattern pattern = Pattern.compile(patternString);
     logger.debug("ProcessWrapper:waitForOutputToMatch waiting for \"{}\"...", patternString);
+    
     while(true) {
-      String line = this.lineBuffer.poll(timeoutMillis, TimeUnit.MILLISECONDS);
-
+      final String line = this.lineBuffer.poll(timeoutMillis, TimeUnit.MILLISECONDS);
       if (line == null) {
-        fail("Timed out waiting for output \"" + patternString + "\" after " + TIMEOUT_MILLIS
+ " ms. Output: " + new OutputFormatter(this.allLines));
+        fail("Timed out waiting for output \"" + patternString + "\" after " + timeoutMillis
+ " ms. Output: " + new OutputFormatter(this.allLines));
       }
       
       if (pattern.matcher(line).matches()) {
@@ -231,19 +221,19 @@ public class ProcessWrapper extends Assert {
    * Waits for the process stdout or stderr stream to contain the specified 
    * text. Uses the default timeout.
    */
-  public ProcessWrapper waitForOutputToMatch(String patternString) throws InterruptedException
{
-    return waitForOutputToMatch(patternString, TIMEOUT_MILLIS);
+  public ProcessWrapper waitForOutputToMatch(final String patternString) throws InterruptedException
{
+    return waitForOutputToMatch(patternString, timeoutMillis);
   }
 
-  public ProcessWrapper execute() throws InterruptedException {
+  public ProcessWrapper execute() throws InterruptedException, TimeoutException {
     return execute(null, new File(System.getProperty("user.dir")));
   }
 
-  public ProcessWrapper execute(Properties props) throws InterruptedException {
-    return execute(props, new File(System.getProperty("user.dir")));
+  public ProcessWrapper execute(final Properties properties) throws InterruptedException,
TimeoutException {
+    return execute(properties, new File(System.getProperty("user.dir")));
   }
   
-  public ProcessWrapper execute(final Properties props, final File workingDirectory) throws
InterruptedException {
+  public ProcessWrapper execute(final Properties properties, final File workingDirectory)
throws InterruptedException, TimeoutException {
     synchronized (this.exitValue) {
       if (this.starting) {
         throw new IllegalStateException("ProcessWrapper can only be executed once");
@@ -251,7 +241,7 @@ public class ProcessWrapper extends Assert {
       this.starting = true;
       this.processThread = new Thread(new Runnable() {
         public void run() {
-          exec(props, workingDirectory);
+          start(properties, workingDirectory);
         }
       }, "ProcessWrapper Process Thread");
     }
@@ -261,7 +251,7 @@ public class ProcessWrapper extends Assert {
 
     synchronized (this.exitValue) {
       if (this.processException != null) {
-        System.out.println("ProcessWrapper:execute failed with " + this.processException);
+        logger.error("ProcessWrapper:execute failed with " + this.processException);
         this.processException.printStackTrace();
       }
     }
@@ -272,36 +262,35 @@ public class ProcessWrapper extends Assert {
     return this;
   }
 
-  private void exec(Properties dsProps, final File workingDirectory) {
-    List<String> vmArgList = new ArrayList<String>();
+  private void start(final Properties properties, final File workingDirectory) {
+    final List<String> jvmArgumentsList = new ArrayList<String>();
 
-    if (dsProps != null) {
-      for (Map.Entry<Object, Object> entry : dsProps.entrySet()) {
+    if (properties != null) {
+      for (Map.Entry<Object, Object> entry : properties.entrySet()) {
         if (!entry.getKey().equals("log-file")) {
-          vmArgList.add("-D" + entry.getKey() + "=" + entry.getValue());
+          jvmArgumentsList.add("-D" + entry.getKey() + "=" + entry.getValue());
         }
       }
     }
 
-    if (JAVA_AWT_HEADLESS) {
-      vmArgList.add("-Djava.awt.headless=true");
+    if (this.headless) {
+      jvmArgumentsList.add("-Djava.awt.headless=true");
     }
     
-    if (this.jvmArgs != null) {
-      for (String vmArg: this.jvmArgs) {
-        vmArgList.add(vmArg);
+    if (this.jvmArguments != null) {
+      for (String jvmArgument: this.jvmArguments) {
+        jvmArgumentsList.add(jvmArgument);
       }
     }
     
-    String[] vmArgs = vmArgList.toArray(new String[vmArgList.size()]);
-
     try {
       synchronized (this.exitValue) {
-        String[] command = defineCommand(vmArgs);
+        final String[] command = defineCommand(jvmArgumentsList.toArray(new String[jvmArgumentsList.size()]));
         this.process = new ProcessBuilder(command).directory(workingDirectory).start();
         
-        StringBuilder processCommand = new StringBuilder();
+        final StringBuilder processCommand = new StringBuilder();
         boolean addSpace = false;
+        
         for (String string : command) {
           if (addSpace) {
             processCommand.append(" ");
@@ -309,16 +298,16 @@ public class ProcessWrapper extends Assert {
           processCommand.append(string);
           addSpace = true;
         }
-        String commandString = processCommand.toString();
-        System.out.println("Executing " + commandString);
+        
+        final String commandString = processCommand.toString();
+        logger.debug("Starting " + commandString);
+        
         final ProcessStreamReader stdOut = new ProcessStreamReader(commandString, this.process.getInputStream(),
this.lineBuffer, this.allLines);
         final ProcessStreamReader stdErr = new ProcessStreamReader(commandString, this.process.getErrorStream(),
this.lineBuffer, this.allLines);
   
         this.stdout = stdOut;
         this.stderr = stdErr;
-  
         this.outputReader = new ProcessOutputReader(this.process, stdOut, stdErr, this.allLines);
-      
         this.started = true;
       }
       
@@ -342,51 +331,40 @@ public class ProcessWrapper extends Assert {
     }
   }
   
-  private String[] defineCommand(String[] vmArgs) {
-    File javabindir = new File(System.getProperty("java.home"), "bin");
-    File javaexe = new File(javabindir, "java");
+  private String[] defineCommand(final String[] jvmArguments) {
+    final File javaBinDir = new File(System.getProperty("java.home"), "bin");
+    final File javaExe = new File(javaBinDir, "java");
 
-    List<String> argList = new ArrayList<String>();
-    argList.add(javaexe.getPath());
-    argList.add("-classpath");
-    argList.add(System.getProperty("java.class.path"));
+    final List<String> argumentList = new ArrayList<String>();
+    argumentList.add(javaExe.getPath());
+    argumentList.add("-classpath");
+    argumentList.add(System.getProperty("java.class.path"));
 
     // -d64 is not a valid option for windows and results in failure
-    int bits = Integer.getInteger("sun.arch.data.model", 0).intValue();
+    final int bits = Integer.getInteger("sun.arch.data.model", 0).intValue();
     if (bits == 64 && !(System.getProperty("os.name").toLowerCase().contains("windows")))
{
-      argList.add("-d64");
+      argumentList.add("-d64");
     }
 
-    argList.add("-Djava.library.path=" + System.getProperty("java.library.path"));
+    argumentList.add("-Djava.library.path=" + System.getProperty("java.library.path"));
 
-    if (vmArgs != null) {
-      argList.addAll(Arrays.asList(vmArgs));
+    if (jvmArguments != null) {
+      argumentList.addAll(Arrays.asList(jvmArguments));
     }
 
     if (this.useMainLauncher) {
-      argList.add(MainLauncher.class.getName());
+      argumentList.add(MainLauncher.class.getName());
     }
-    argList.add(mainClass.getName());
+    argumentList.add(mainClass.getName());
     
-    if (mainArgs != null) {
-      argList.addAll(Arrays.asList(mainArgs));
+    if (mainArguments != null) {
+      argumentList.addAll(Arrays.asList(mainArguments));
     }
 
-    String[] cmd = argList.toArray(new String[argList.size()]);
-    return cmd;
+    final String[] command = argumentList.toArray(new String[argumentList.size()]);
+    return command;
   }
   
-  private String toString(String[] strings) {
-    if (strings == null || strings.length < 1) {
-      return null;
-    }
-    StringBuilder sb = new StringBuilder();
-    for (String string : strings) {
-      sb.append(string).append("\n");
-    }
-    return sb.toString();
-  }
-
   private void checkStarting() throws IllegalStateException {
     synchronized (this.exitValue) {
       if (!this.starting) {
@@ -405,8 +383,7 @@ public class ProcessWrapper extends Assert {
   
   private void checkOk() throws RuntimeException {
     if (this.processException != null) {
-      RuntimeException rt = new RuntimeException("Failed to launch process", this.processException);
-      throw rt;
+      throw new RuntimeException("Failed to launch process", this.processException);
     }
   }
 
@@ -416,8 +393,9 @@ public class ProcessWrapper extends Assert {
     }
   }
   
+  @Override
   public String toString() {
-    StringBuilder sb = new StringBuilder(getClass().getSimpleName());
+    final StringBuilder sb = new StringBuilder(getClass().getSimpleName());
     sb.append("@").append(System.identityHashCode(this)).append("{");
     sb.append(this.mainClass);
     sb.append("}");
@@ -425,31 +403,46 @@ public class ProcessWrapper extends Assert {
   }
 
   public static class Builder {
-    private String[] jvmArgs = null;
-    private Class<?> main;
-    private String[] mainArgs = null;
+    private String[] jvmArguments = null;
+    private Class<?> mainClass;
+    private String[] mainArguments = null;
     private boolean useMainLauncher = true;
+    private boolean headless = true;
+    private long timeoutMillis = TIMEOUT_MILLIS_DEFAULT;
+    private boolean inline = false;
     public Builder() {
       //nothing
     }
-    public Builder jvmArgs(String[] jvmArgs) {
-      this.jvmArgs = jvmArgs;
+    public Builder jvmArguments(final String[] jvmArguments) {
+      this.jvmArguments = jvmArguments;
       return this;
     }
-    public Builder main(Class<?> main) { 
-      this.main = main;
+    public Builder mainClass(final Class<?> mainClass) { 
+      this.mainClass = mainClass;
       return this;
     }
-    public Builder mainArgs(String[] mainArgs) {
-      this.mainArgs = mainArgs;
+    public Builder mainArguments(final String[] mainArguments) {
+      this.mainArguments = mainArguments;
       return this;
     }
-    public Builder useMainLauncher(boolean useMainLauncher) {
+    public Builder useMainLauncher(final boolean useMainLauncher) {
       this.useMainLauncher = useMainLauncher;
       return this;
     }
+    public Builder headless(final boolean headless) {
+      this.headless = headless;
+      return this;
+    }
+    public Builder timeoutMillis(final long timeoutMillis) {
+      this.timeoutMillis = timeoutMillis;
+      return this;
+    }
+    public Builder inline(final boolean inline) {
+      this.inline = inline;
+      return this;
+    }
     public ProcessWrapper build() {
-      return new ProcessWrapper(jvmArgs, main, mainArgs, useMainLauncher);
+      return new ProcessWrapper(jvmArguments, mainClass, mainArguments, useMainLauncher,
headless, timeoutMillis);
     }
   }
 }

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/94939c1f/gemfire-core/src/test/java/com/gemstone/gemfire/test/process/ProcessWrapperJUnitTest.java
----------------------------------------------------------------------
diff --git a/gemfire-core/src/test/java/com/gemstone/gemfire/test/process/ProcessWrapperJUnitTest.java
b/gemfire-core/src/test/java/com/gemstone/gemfire/test/process/ProcessWrapperJUnitTest.java
index 7c08fcc..a548e75 100755
--- a/gemfire-core/src/test/java/com/gemstone/gemfire/test/process/ProcessWrapperJUnitTest.java
+++ b/gemfire-core/src/test/java/com/gemstone/gemfire/test/process/ProcessWrapperJUnitTest.java
@@ -6,18 +6,14 @@ import org.junit.After;
 import org.junit.Test;
 import org.junit.experimental.categories.Category;
 
-import com.gemstone.gemfire.test.junit.categories.UnitTest;
-
-import org.junit.experimental.categories.Category;
-
-import com.gemstone.gemfire.test.junit.categories.UnitTest;
+import com.gemstone.gemfire.test.junit.categories.IntegrationTest;
 
 /**
- * Unit test basic functionality in ProcessWrapper.
+ * Integration tests for ProcessWrapper.
  * 
  * @author Kirk Lund
  */
-@Category(UnitTest.class)
+@Category(IntegrationTest.class)
 public class ProcessWrapperJUnitTest {
 
   private static final String OUTPUT_OF_MAIN = "Executing ProcessWrapperJUnitTest main";
@@ -33,23 +29,20 @@ public class ProcessWrapperJUnitTest {
   @Test
   public void testClassPath() throws Exception {
     final String classPath = System.getProperty("java.class.path");
-    System.out.println("Classpath: " + classPath);
     assertTrue("Classpath is missing log4j-api: " + classPath, classPath.toLowerCase().contains("log4j-api"));
     assertTrue("Classpath is missing log4j-core: " + classPath, classPath.toLowerCase().contains("log4j-core"));
     assertTrue("Classpath is missing fastutil: " + classPath, classPath.toLowerCase().contains("fastutil"));
   
-    System.out.println(String.valueOf(Integer.MAX_VALUE));
-    
-    this.process = new ProcessWrapper.Builder().main(getClass()).build();
+    this.process = new ProcessWrapper.Builder().mainClass(getClass()).build();
     this.process.execute();
     this.process.waitFor();
-    System.out.println("Output: " + process.getOutput());
+    
     assertTrue("Output is wrong: " + process.getOutput(), process.getOutput().contains(OUTPUT_OF_MAIN));
   }
   
   @Test
   public void testInvokeWithNullArgs() throws Exception {
-    this.process = new ProcessWrapper.Builder().main(getClass()).build();
+    this.process = new ProcessWrapper.Builder().mainClass(getClass()).build();
     this.process.execute();
     this.process.waitFor();
     assertTrue(process.getOutput().contains(OUTPUT_OF_MAIN));

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/94939c1f/gemfire-core/src/test/resources/com/gemstone/gemfire/test/golden/log4j2-test.xml
----------------------------------------------------------------------
diff --git a/gemfire-core/src/test/resources/com/gemstone/gemfire/test/golden/log4j2-test.xml
b/gemfire-core/src/test/resources/com/gemstone/gemfire/test/golden/log4j2-test.xml
new file mode 100755
index 0000000..6a885ef
--- /dev/null
+++ b/gemfire-core/src/test/resources/com/gemstone/gemfire/test/golden/log4j2-test.xml
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Configuration status="ERROR" shutdownHook="disable" packages="com.gemstone.org.apache.logging.log4j.core.config.xml,com.gemstone.gemfire.internal.logging.log4j">
+  <Properties>
+    <Property name="gemfire-pattern">[%level{lowerCase=true} %date{yyyy/MM/dd HH:mm:ss.SSS
z} &lt;%thread&gt; tid=%tid] %message%n%throwable%n</Property>
+  </Properties>
+  <Appenders>
+    <Console name="STDOUT" target="SYSTEM_OUT">
+      <PatternLayout pattern="${gemfire-pattern}"/>
+    </Console>
+  </Appenders>
+  <Loggers>
+    <Logger name="com.gemstone" level="WARN" additivity="true"/>
+    <Logger name="quickstart" level="WARN" additivity="true"/>
+    <Root level="ERROR">
+      <AppenderRef ref="STDOUT"/>
+    </Root>
+  </Loggers>
+</Configuration>


Mime
View raw message