geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ash...@apache.org
Subject [2/7] incubator-geode git commit: GEODE-10: Refactor HdfsStore api to match spec
Date Fri, 17 Jul 2015 06:03:29 GMT
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/3772869d/gemfire-core/src/main/java/com/gemstone/gemfire/management/internal/cli/commands/HDFSStoreCommands.java
----------------------------------------------------------------------
diff --git a/gemfire-core/src/main/java/com/gemstone/gemfire/management/internal/cli/commands/HDFSStoreCommands.java b/gemfire-core/src/main/java/com/gemstone/gemfire/management/internal/cli/commands/HDFSStoreCommands.java
index b044156..a2f4138 100644
--- a/gemfire-core/src/main/java/com/gemstone/gemfire/management/internal/cli/commands/HDFSStoreCommands.java
+++ b/gemfire-core/src/main/java/com/gemstone/gemfire/management/internal/cli/commands/HDFSStoreCommands.java
@@ -6,7 +6,6 @@ import java.util.Comparator;
 import java.util.List;
 import java.util.Set;
 
-import org.apache.logging.log4j.Logger;
 import org.springframework.shell.core.annotation.CliAvailabilityIndicator;
 import org.springframework.shell.core.annotation.CliCommand;
 import org.springframework.shell.core.annotation.CliOption;
@@ -16,19 +15,10 @@ import com.gemstone.gemfire.cache.Cache;
 import com.gemstone.gemfire.cache.execute.Execution;
 import com.gemstone.gemfire.cache.execute.FunctionInvocationTargetException;
 import com.gemstone.gemfire.cache.execute.ResultCollector;
-import com.gemstone.gemfire.cache.hdfs.HDFSEventQueueAttributes;
-import com.gemstone.gemfire.cache.hdfs.HDFSEventQueueAttributesFactory;
-import com.gemstone.gemfire.cache.hdfs.HDFSStoreFactory.HDFSCompactionConfigFactory;
-import com.gemstone.gemfire.cache.hdfs.HDFSStoreMutator;
-import com.gemstone.gemfire.cache.hdfs.HDFSStoreMutator.HDFSCompactionConfigMutator;
-import com.gemstone.gemfire.cache.hdfs.HDFSStoreMutator.HDFSEventQueueAttributesMutator;
 import com.gemstone.gemfire.cache.hdfs.internal.HDFSStoreConfigHolder;
-import com.gemstone.gemfire.cache.hdfs.internal.HDFSStoreConfigHolder.AbstractHDFSCompactionConfigHolder;
-import com.gemstone.gemfire.cache.hdfs.internal.HDFSStoreMutatorImpl;
 import com.gemstone.gemfire.distributed.DistributedMember;
 import com.gemstone.gemfire.internal.cache.execute.AbstractExecution;
 import com.gemstone.gemfire.internal.lang.ClassUtils;
-import com.gemstone.gemfire.internal.logging.LogService;
 import com.gemstone.gemfire.management.cli.CliMetaData;
 import com.gemstone.gemfire.management.cli.ConverterHint;
 import com.gemstone.gemfire.management.cli.Result;
@@ -200,7 +190,6 @@ public class HDFSStoreCommands   extends AbstractCommandsSupport {
       Integer majorCompactionThreads, Integer minorCompactionThreads, Integer purgeInterval, Integer maxMemory) {
 
     XmlEntity xmlEntity = null;
-    Logger logger = LogService.getLogger();
 
     Set<DistributedMember> targetMembers = null;
 
@@ -216,52 +205,44 @@ public class HDFSStoreCommands   extends AbstractCommandsSupport {
       configHolder.setBlockCacheSize(readCacheSize);
 
     if (fileRolloverInterval != null)
-      configHolder.setFileRolloverInterval(fileRolloverInterval);
+      configHolder.setWriteOnlyFileRolloverInterval(fileRolloverInterval);
     if (clientConfigFile != null)
       configHolder.setHDFSClientConfigFile(clientConfigFile);
     if (homeDir != null)
       configHolder.setHomeDir(homeDir);
     if (maxWriteonlyFileSize != null)
-      configHolder.setMaxFileSize(maxWriteonlyFileSize);
+      configHolder.setMaxWriteOnlyFileSize(maxWriteonlyFileSize);
     if (namenode != null)
       configHolder.setNameNodeURL(namenode);
 
-    HDFSCompactionConfigFactory compactionConfig = configHolder.createCompactionConfigFactory(null);
     if (minorCompact != null)
       configHolder.setMinorCompaction(minorCompact);
     if (majorCompact != null)
-      compactionConfig.setAutoMajorCompaction(majorCompact);
+      configHolder.setMajorCompaction(majorCompact);
     if (majorCompactionInterval != null)
-      compactionConfig.setMajorCompactionIntervalMins(majorCompactionInterval);
+      configHolder.setMajorCompactionInterval(majorCompactionInterval);
     if (majorCompactionThreads != null)
-      compactionConfig.setMajorCompactionMaxThreads(majorCompactionThreads);
+      configHolder.setMajorCompactionThreads(majorCompactionThreads);
     if (minorCompactionThreads != null)
-      compactionConfig.setMaxThreads(minorCompactionThreads);
+      configHolder.setMinorCompactionThreads(minorCompactionThreads);
     if (purgeInterval != null)
-      compactionConfig.setOldFilesCleanupIntervalMins(purgeInterval);
-
-    configHolder.setHDFSCompactionConfig(compactionConfig.create());
-
-    HDFSEventQueueAttributesFactory eventQueue = new HDFSEventQueueAttributesFactory();
+      configHolder.setPurgeInterval(purgeInterval);
 
     if (batchSize != null)
-      eventQueue.setBatchSizeMB(batchSize);
+      configHolder.setBatchSize(batchSize);
     if (batchInterval != null)
-      eventQueue.setBatchTimeInterval(batchInterval);
+      configHolder.setBatchInterval(batchInterval);
     if (diskStoreName != null)
-      eventQueue.setDiskStoreName(diskStoreName);
+      configHolder.setDiskStoreName(diskStoreName);
     if (syncDiskWrite != null)
-      eventQueue.setDiskSynchronous(syncDiskWrite);
+      configHolder.setSynchronousDiskWrite(syncDiskWrite);
     if (dispatcherThreads != null)
-      eventQueue.setDispatcherThreads(dispatcherThreads);
+      configHolder.setDispatcherThreads(dispatcherThreads);
     if (maxMemory != null)
-      eventQueue.setMaximumQueueMemory(maxMemory);
+      configHolder.setMaxMemory(maxMemory);
     if (bufferPersistent != null)
-      eventQueue.setPersistent(bufferPersistent);
+      configHolder.setBufferPersistent(bufferPersistent);
 
-    configHolder.setHDFSEventQueueAttributes(eventQueue.create());
-
-    
     ResultCollector<?, ?> resultCollector = getMembersFunctionExecutor(targetMembers)
     .withArgs(configHolder).execute(new CreateHDFSStoreFunction());
     
@@ -374,29 +355,25 @@ public class HDFSStoreCommands   extends AbstractCommandsSupport {
     hdfsStoreSection.addData("Name Node URL", storePrms.getNameNodeURL());
     hdfsStoreSection.addData("Home Dir", storePrms.getHomeDir());
     hdfsStoreSection.addData("Block Cache", storePrms.getBlockCacheSize());
-    hdfsStoreSection.addData("File RollOver Interval", storePrms.getFileRolloverInterval());
-    hdfsStoreSection.addData("Max WriteOnly File Size", storePrms.getMaxFileSize());
+    hdfsStoreSection.addData("File RollOver Interval", storePrms.getWriteOnlyFileRolloverInterval());
+    hdfsStoreSection.addData("Max WriteOnly File Size", storePrms.getMaxWriteOnlyFileSize());
 
     hdfsStoreSection.addData("Client Configuration File", storePrms.getHDFSClientConfigFile());
 
-    HDFSEventQueueAttributes queueAttr = storePrms.getHDFSEventQueueAttributes();
-
-    hdfsStoreSection.addData("Disk Store Name", queueAttr.getDiskStoreName());
-    hdfsStoreSection.addData("Batch Size In MB", queueAttr.getBatchSizeMB());
-    hdfsStoreSection.addData("Batch Interval Time", queueAttr.getBatchTimeInterval());
-    hdfsStoreSection.addData("Maximum Memory", queueAttr.getMaximumQueueMemory());
-    hdfsStoreSection.addData("Dispatcher Threads", queueAttr.getDispatcherThreads());
-    hdfsStoreSection.addData("Buffer Persistence", queueAttr.isPersistent());
-    hdfsStoreSection.addData("Synchronous Persistence", queueAttr.isDiskSynchronous());
-
-    AbstractHDFSCompactionConfigHolder compaction = storePrms.getHDFSCompactionConfig();
-
-    hdfsStoreSection.addData("Major Compaction Enabled", compaction.getAutoMajorCompaction());
-    hdfsStoreSection.addData("Major Compaction Threads", compaction.getMajorCompactionMaxThreads());
-    hdfsStoreSection.addData("Major compaction Interval", compaction.getMajorCompactionIntervalMins());
+    hdfsStoreSection.addData("Disk Store Name", storePrms.getDiskStoreName());
+    hdfsStoreSection.addData("Batch Size In MB", storePrms.getBatchSize());
+    hdfsStoreSection.addData("Batch Interval Time", storePrms.getBatchInterval());
+    hdfsStoreSection.addData("Maximum Memory", storePrms.getMaxMemory());
+    hdfsStoreSection.addData("Dispatcher Threads", storePrms.getDispatcherThreads());
+    hdfsStoreSection.addData("Buffer Persistence", storePrms.getBufferPersistent());
+    hdfsStoreSection.addData("Synchronous Persistence", storePrms.getSynchronousDiskWrite());
+
+    hdfsStoreSection.addData("Major Compaction Enabled", storePrms.getMajorCompaction());
+    hdfsStoreSection.addData("Major Compaction Threads", storePrms.getMajorCompactionThreads());
+    hdfsStoreSection.addData("Major compaction Interval", storePrms.getMajorCompactionInterval());
     hdfsStoreSection.addData("Minor Compaction Enabled", storePrms.getMinorCompaction());
-    hdfsStoreSection.addData("Minor Compaction Threads", compaction.getMaxThreads());
-    hdfsStoreSection.addData("Purge Interval", compaction.getOldFilesCleanupIntervalMins());
+    hdfsStoreSection.addData("Minor Compaction Threads", storePrms.getMinorCompactionThreads());
+    hdfsStoreSection.addData("Purge Interval", storePrms.getPurgeInterval());
 
     return ResultBuilder.buildResult(hdfsStoreCompositeResult);
   } 

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/3772869d/gemfire-core/src/main/java/com/gemstone/gemfire/management/internal/cli/functions/AlterHDFSStoreFunction.java
----------------------------------------------------------------------
diff --git a/gemfire-core/src/main/java/com/gemstone/gemfire/management/internal/cli/functions/AlterHDFSStoreFunction.java b/gemfire-core/src/main/java/com/gemstone/gemfire/management/internal/cli/functions/AlterHDFSStoreFunction.java
index 13ba5fa..adec764 100644
--- a/gemfire-core/src/main/java/com/gemstone/gemfire/management/internal/cli/functions/AlterHDFSStoreFunction.java
+++ b/gemfire-core/src/main/java/com/gemstone/gemfire/management/internal/cli/functions/AlterHDFSStoreFunction.java
@@ -19,8 +19,6 @@ import com.gemstone.gemfire.cache.execute.FunctionAdapter;
 import com.gemstone.gemfire.cache.execute.FunctionContext;
 import com.gemstone.gemfire.cache.hdfs.HDFSStore;
 import com.gemstone.gemfire.cache.hdfs.HDFSStoreMutator;
-import com.gemstone.gemfire.cache.hdfs.HDFSStoreMutator.HDFSCompactionConfigMutator;
-import com.gemstone.gemfire.cache.hdfs.HDFSStoreMutator.HDFSEventQueueAttributesMutator;
 import com.gemstone.gemfire.cache.hdfs.internal.HDFSStoreMutatorImpl;
 import com.gemstone.gemfire.distributed.DistributedMember;
 import com.gemstone.gemfire.internal.InternalEntity;
@@ -107,39 +105,35 @@ public class AlterHDFSStoreFunction extends FunctionAdapter implements InternalE
     HDFSStoreMutator storeMutator = new HDFSStoreMutatorImpl(hdfsStore);
   
 		if (alterAttributes.getFileRolloverInterval() != null)
-			storeMutator.setFileRolloverInterval(alterAttributes
+			storeMutator.setWriteOnlyFileRolloverInterval(alterAttributes
 					.getFileRolloverInterval());
 
 		if (alterAttributes.getMaxWriteonlyFileSize() != null)
-			storeMutator.setMaxFileSize(alterAttributes.getMaxWriteonlyFileSize());
-
-		HDFSCompactionConfigMutator compactionMutator = storeMutator.getCompactionConfigMutator();
+			storeMutator.setMaxWriteOnlyFileSize(alterAttributes.getMaxWriteonlyFileSize());
 
 		if (alterAttributes.getMinorCompact() != null)
 			storeMutator.setMinorCompaction(alterAttributes.getMinorCompact());
 
 		if (alterAttributes.getMajorCompact() != null)
-			compactionMutator.setAutoMajorCompaction(alterAttributes.getMajorCompact());
+		  storeMutator.setMajorCompaction(alterAttributes.getMajorCompact());
 
 		if (alterAttributes.getMajorCompactionInterval() != null)
-			compactionMutator.setMajorCompactionIntervalMins(alterAttributes.getMajorCompactionInterval());
+		  storeMutator.setMajorCompactionInterval(alterAttributes.getMajorCompactionInterval());
 
 		if (alterAttributes.getMajorCompactionThreads() != null)
-			compactionMutator.setMajorCompactionMaxThreads(alterAttributes.getMajorCompactionThreads());
+		  storeMutator.setMajorCompactionThreads(alterAttributes.getMajorCompactionThreads());
 
 		if (alterAttributes.getMajorCompactionThreads() != null)
-			compactionMutator.setMaxThreads(alterAttributes.getMajorCompactionThreads());
+		  storeMutator.setMinorCompactionThreads(alterAttributes.getMajorCompactionThreads());
 
 		if (alterAttributes.getPurgeInterval() != null)
-			compactionMutator.setOldFilesCleanupIntervalMins(alterAttributes.getPurgeInterval());
+			storeMutator.setPurgeInterval(alterAttributes.getPurgeInterval());
 
-		HDFSEventQueueAttributesMutator eventQueueMutator = storeMutator.getHDFSEventQueueAttributesMutator();
-		
 		if (alterAttributes.getBatchSize() != null)
-			eventQueueMutator.setBatchSizeMB(alterAttributes.getBatchSize());
+		  storeMutator.setBatchSize(alterAttributes.getBatchSize());
 
 		if (alterAttributes.getBatchInterval() != null)
-			eventQueueMutator.setBatchTimeInterval(alterAttributes.getBatchInterval());
+		  storeMutator.setBatchInterval(alterAttributes.getBatchInterval());
 
 		hdfsStore.alter(storeMutator);
 		return hdfsStore;

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/3772869d/gemfire-core/src/main/java/com/gemstone/gemfire/management/internal/cli/functions/CreateHDFSStoreFunction.java
----------------------------------------------------------------------
diff --git a/gemfire-core/src/main/java/com/gemstone/gemfire/management/internal/cli/functions/CreateHDFSStoreFunction.java b/gemfire-core/src/main/java/com/gemstone/gemfire/management/internal/cli/functions/CreateHDFSStoreFunction.java
index ac9c895..460feba 100644
--- a/gemfire-core/src/main/java/com/gemstone/gemfire/management/internal/cli/functions/CreateHDFSStoreFunction.java
+++ b/gemfire-core/src/main/java/com/gemstone/gemfire/management/internal/cli/functions/CreateHDFSStoreFunction.java
@@ -88,12 +88,22 @@ public class CreateHDFSStoreFunction extends FunctionAdapter implements Internal
     hdfsStoreFactory.setName(configHolder.getName());
     hdfsStoreFactory.setNameNodeURL(configHolder.getNameNodeURL());
     hdfsStoreFactory.setBlockCacheSize(configHolder.getBlockCacheSize());
-    hdfsStoreFactory.setFileRolloverInterval(configHolder.getFileRolloverInterval());
+    hdfsStoreFactory.setWriteOnlyFileRolloverInterval(configHolder.getWriteOnlyFileRolloverInterval());
     hdfsStoreFactory.setHomeDir(configHolder.getHomeDir());
-    hdfsStoreFactory.setHDFSEventQueueAttributes(configHolder.getHDFSEventQueueAttributes());
     hdfsStoreFactory.setHDFSClientConfigFile(configHolder.getHDFSClientConfigFile());
-    hdfsStoreFactory.setHDFSCompactionConfig(configHolder.getHDFSCompactionConfig());
-    hdfsStoreFactory.setMaxFileSize(configHolder.getMaxFileSize());
+    hdfsStoreFactory.setMaxWriteOnlyFileSize(configHolder.getMaxWriteOnlyFileSize());
+    hdfsStoreFactory.setMajorCompaction(configHolder.getMajorCompaction());
+    hdfsStoreFactory.setMajorCompactionInterval(configHolder.getMajorCompactionInterval());
+    hdfsStoreFactory.setMajorCompactionThreads(configHolder.getMajorCompactionThreads());
+    hdfsStoreFactory.setMinorCompaction(configHolder.getMinorCompaction());
+    
+    hdfsStoreFactory.setBatchSize(configHolder.getBatchSize());
+    hdfsStoreFactory.setBatchInterval(configHolder.getBatchInterval());
+    hdfsStoreFactory.setDiskStoreName(configHolder.getDiskStoreName());
+    hdfsStoreFactory.setDispatcherThreads(configHolder.getDispatcherThreads());
+    hdfsStoreFactory.setSynchronousDiskWrite(configHolder.getSynchronousDiskWrite());
+    hdfsStoreFactory.setBufferPersistent(configHolder.getBufferPersistent());
+    
     return hdfsStoreFactory.create(configHolder.getName());   
   }
   

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/3772869d/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/ColocatedRegionWithHDFSDUnitTest.java
----------------------------------------------------------------------
diff --git a/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/ColocatedRegionWithHDFSDUnitTest.java b/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/ColocatedRegionWithHDFSDUnitTest.java
index ea9dc11..cf658d1 100644
--- a/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/ColocatedRegionWithHDFSDUnitTest.java
+++ b/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/ColocatedRegionWithHDFSDUnitTest.java
@@ -10,7 +10,6 @@ package com.gemstone.gemfire.cache.hdfs.internal;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Map;
-import java.util.Properties;
 
 import com.gemstone.gemfire.cache.AttributesFactory;
 import com.gemstone.gemfire.cache.DataPolicy;
@@ -18,11 +17,8 @@ import com.gemstone.gemfire.cache.EvictionAction;
 import com.gemstone.gemfire.cache.EvictionAttributes;
 import com.gemstone.gemfire.cache.PartitionAttributesFactory;
 import com.gemstone.gemfire.cache.Region;
-import com.gemstone.gemfire.cache.hdfs.HDFSEventQueueAttributesFactory;
 import com.gemstone.gemfire.cache.hdfs.HDFSStoreFactory;
-import com.gemstone.gemfire.internal.cache.GemFireCacheImpl;
 import com.gemstone.gemfire.internal.cache.LocalRegion;
-import com.gemstone.gemfire.internal.i18n.LocalizedStrings;
 
 import dunit.AsyncInvocation;
 import dunit.SerializableCallable;
@@ -48,16 +44,12 @@ public class ColocatedRegionWithHDFSDUnitTest extends RegionWithHDFSTestBase {
       final long timeForRollover, final long maxFileSize) {
     SerializableCallable createRegion = new SerializableCallable() {
       public Object call() throws Exception {
-        HDFSEventQueueAttributesFactory hqf = new HDFSEventQueueAttributesFactory();
-        hqf.setBatchSizeMB(batchSizeMB);
-        hqf.setPersistent(queuePersistent);
-        hqf.setMaximumQueueMemory(3);
-        hqf.setBatchTimeInterval(batchInterval);
-
         HDFSStoreFactory hsf = getCache().createHDFSStoreFactory();
-        String homeDir = tmpDir + "/" + folderPath;
-        hsf.setHomeDir(homeDir);
-        hsf.setHDFSEventQueueAttributes(hqf.create());
+        hsf.setBatchSize(batchSizeMB);
+        hsf.setBufferPersistent(queuePersistent);
+        hsf.setMaxMemory(3);
+        hsf.setBatchInterval(batchInterval);
+        hsf.setHomeDir(tmpDir + "/" + folderPath);
         hsf.create(uniqueName);
 
         AttributesFactory af = new AttributesFactory();

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/3772869d/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/HDFSConfigJUnitTest.java
----------------------------------------------------------------------
diff --git a/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/HDFSConfigJUnitTest.java b/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/HDFSConfigJUnitTest.java
index dc3f404..0756e27 100644
--- a/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/HDFSConfigJUnitTest.java
+++ b/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/HDFSConfigJUnitTest.java
@@ -20,18 +20,14 @@ import junit.framework.TestCase;
 
 import com.gemstone.gemfire.cache.CacheFactory;
 import com.gemstone.gemfire.cache.CacheXmlException;
-import com.gemstone.gemfire.cache.DiskStore;
 import com.gemstone.gemfire.cache.DiskStoreFactory;
 import com.gemstone.gemfire.cache.EvictionAttributes;
 import com.gemstone.gemfire.cache.Region;
 import com.gemstone.gemfire.cache.RegionFactory;
 import com.gemstone.gemfire.cache.RegionShortcut;
 import com.gemstone.gemfire.cache.asyncqueue.internal.AsyncEventQueueImpl;
-import com.gemstone.gemfire.cache.hdfs.HDFSEventQueueAttributesFactory;
 import com.gemstone.gemfire.cache.hdfs.HDFSStore;
-import com.gemstone.gemfire.cache.hdfs.HDFSStore.HDFSCompactionConfig;
 import com.gemstone.gemfire.cache.hdfs.HDFSStoreFactory;
-import com.gemstone.gemfire.cache.hdfs.HDFSStoreFactory.HDFSCompactionConfigFactory;
 import com.gemstone.gemfire.cache.hdfs.internal.hoplog.AbstractHoplogOrganizer;
 import com.gemstone.gemfire.cache.hdfs.internal.hoplog.HoplogConfig;
 import com.gemstone.gemfire.internal.cache.GemFireCacheImpl;
@@ -43,8 +39,6 @@ import com.gemstone.gemfire.test.junit.categories.IntegrationTest;
 import org.apache.hadoop.hbase.regionserver.StoreFile;
 import org.junit.experimental.categories.Category;
 
-import dunit.VM;
-
 /**
  * A test class for testing the configuration option for HDFS 
  * 
@@ -82,12 +76,12 @@ public class HDFSConfigJUnitTest extends TestCase {
        
         r1.put("k1", "v1");
         
-        assertTrue("Mismatch in attributes, actual.batchsize: " + store.getHDFSEventQueueAttributes().getBatchSizeMB() + " and expected batchsize: 32", store.getHDFSEventQueueAttributes().getBatchSizeMB()== 32);
-        assertTrue("Mismatch in attributes, actual.isPersistent: " + store.getHDFSEventQueueAttributes().isPersistent() + " and expected isPersistent: false", store.getHDFSEventQueueAttributes().isPersistent()== false);
+        assertTrue("Mismatch in attributes, actual.batchsize: " + store.getBatchSize() + " and expected batchsize: 32", store.getBatchSize()== 32);
+        assertTrue("Mismatch in attributes, actual.isPersistent: " + store.getBufferPersistent() + " and expected isPersistent: false", store.getBufferPersistent()== false);
         assertEquals(false, r1.getAttributes().getHDFSWriteOnly());
-        assertTrue("Mismatch in attributes, actual.getDiskStoreName: " + store.getHDFSEventQueueAttributes().getDiskStoreName() + " and expected getDiskStoreName: null", store.getHDFSEventQueueAttributes().getDiskStoreName()== null);
-        assertTrue("Mismatch in attributes, actual.getFileRolloverInterval: " + store.getFileRolloverInterval() + " and expected getFileRolloverInterval: 3600", store.getFileRolloverInterval() == 3600);
-        assertTrue("Mismatch in attributes, actual.getMaxFileSize: " + store.getMaxFileSize() + " and expected getMaxFileSize: 256MB", store.getMaxFileSize() == 256);
+        assertTrue("Mismatch in attributes, actual.getDiskStoreName: " + store.getDiskStoreName() + " and expected getDiskStoreName: null", store.getDiskStoreName()== null);
+        assertTrue("Mismatch in attributes, actual.getFileRolloverInterval: " + store.getWriteOnlyFileRolloverInterval() + " and expected getFileRolloverInterval: 3600", store.getWriteOnlyFileRolloverInterval() == 3600);
+        assertTrue("Mismatch in attributes, actual.getMaxFileSize: " + store.getMaxWriteOnlyFileSize() + " and expected getMaxFileSize: 256MB", store.getMaxWriteOnlyFileSize() == 256);
         this.c.close();
         
         
@@ -99,12 +93,12 @@ public class HDFSConfigJUnitTest extends TestCase {
               .create("r1");
        
         r1.put("k1", "v1");
-        assertTrue("Mismatch in attributes, actual.batchsize: " + store.getHDFSEventQueueAttributes().getBatchSizeMB() + " and expected batchsize: 32", store.getHDFSEventQueueAttributes().getBatchSizeMB()== 32);
-        assertTrue("Mismatch in attributes, actual.isPersistent: " + store.getHDFSEventQueueAttributes().isPersistent() + " and expected isPersistent: false", store.getHDFSEventQueueAttributes().isPersistent()== false);
+        assertTrue("Mismatch in attributes, actual.batchsize: " + store.getBatchSize() + " and expected batchsize: 32", store.getBatchSize()== 32);
+        assertTrue("Mismatch in attributes, actual.isPersistent: " + store.getBufferPersistent() + " and expected isPersistent: false", store.getBufferPersistent()== false);
         assertTrue("Mismatch in attributes, actual.isRandomAccessAllowed: " + r1.getAttributes().getHDFSWriteOnly() + " and expected isRandomAccessAllowed: true", r1.getAttributes().getHDFSWriteOnly()== true);
-        assertTrue("Mismatch in attributes, actual.getDiskStoreName: " + store.getHDFSEventQueueAttributes().getDiskStoreName() + " and expected getDiskStoreName: null", store.getHDFSEventQueueAttributes().getDiskStoreName()== null);
-        assertTrue("Mismatch in attributes, actual.batchInterval: " + store.getHDFSEventQueueAttributes().getBatchTimeInterval() + " and expected batchsize: 60000", store.getHDFSEventQueueAttributes().getBatchTimeInterval()== 60000);
-        assertTrue("Mismatch in attributes, actual.isDiskSynchronous: " + store.getHDFSEventQueueAttributes().isDiskSynchronous() + " and expected isDiskSynchronous: true", store.getHDFSEventQueueAttributes().isDiskSynchronous()== true);
+        assertTrue("Mismatch in attributes, actual.getDiskStoreName: " + store.getDiskStoreName() + " and expected getDiskStoreName: null", store.getDiskStoreName()== null);
+        assertTrue("Mismatch in attributes, actual.batchInterval: " + store.getBatchInterval() + " and expected batchsize: 60000", store.getBatchInterval()== 60000);
+        assertTrue("Mismatch in attributes, actual.isDiskSynchronous: " + store.getSynchronousDiskWrite() + " and expected isDiskSynchronous: true", store.getSynchronousDiskWrite()== true);
         
         this.c.close();
 
@@ -116,21 +110,19 @@ public class HDFSConfigJUnitTest extends TestCase {
         File[] dirs1 = new File[] { directory };
         DiskStoreFactory dsf = this.c.createDiskStoreFactory();
         dsf.setDiskDirs(dirs1);
-        DiskStore diskStore = dsf.create("mydisk");
+        dsf.create("mydisk");
         
-        HDFSEventQueueAttributesFactory hqf= new HDFSEventQueueAttributesFactory();
-        hqf.setBatchSizeMB(50);
-        hqf.setDiskStoreName("mydisk");
-        hqf.setPersistent(true);
-        hqf.setBatchTimeInterval(50);
-        hqf.setDiskSynchronous(false);
         
         hsf = this.c.createHDFSStoreFactory();
+        hsf.setBatchSize(50);
+        hsf.setDiskStoreName("mydisk");
+        hsf.setBufferPersistent(true);
+        hsf.setBatchInterval(50);
+        hsf.setSynchronousDiskWrite(false);
         hsf.setHomeDir("/home/hemant");
         hsf.setNameNodeURL("mymachine");
-        hsf.setHDFSEventQueueAttributes(hqf.create());
-        hsf.setMaxFileSize(1);
-        hsf.setFileRolloverInterval(10);
+        hsf.setMaxWriteOnlyFileSize(1);
+        hsf.setWriteOnlyFileRolloverInterval(10);
         hsf.create("myHDFSStore");
         
         
@@ -140,17 +132,17 @@ public class HDFSConfigJUnitTest extends TestCase {
         r1.put("k1", "v1");
         store = c.findHDFSStore(r1.getAttributes().getHDFSStoreName());
         
-        assertTrue("Mismatch in attributes, actual.batchsize: " + store.getHDFSEventQueueAttributes().getBatchSizeMB() + " and expected batchsize: 50", store.getHDFSEventQueueAttributes().getBatchSizeMB()== 50);
-        assertTrue("Mismatch in attributes, actual.isPersistent: " + store.getHDFSEventQueueAttributes().isPersistent() + " and expected isPersistent: true", store.getHDFSEventQueueAttributes().isPersistent()== true);
+        assertTrue("Mismatch in attributes, actual.batchsize: " + store.getBatchSize() + " and expected batchsize: 50", store.getBatchSize()== 50);
+        assertTrue("Mismatch in attributes, actual.isPersistent: " + store.getBufferPersistent() + " and expected isPersistent: true", store.getBufferPersistent()== true);
         assertTrue("Mismatch in attributes, actual.isRandomAccessAllowed: " + r1.getAttributes().getHDFSWriteOnly() + " and expected isRandomAccessAllowed: true", r1.getAttributes().getHDFSWriteOnly()== true);
-        assertTrue("Mismatch in attributes, actual.getDiskStoreName: " + store.getHDFSEventQueueAttributes().getDiskStoreName() + " and expected getDiskStoreName: mydisk", store.getHDFSEventQueueAttributes().getDiskStoreName()== "mydisk");
+        assertTrue("Mismatch in attributes, actual.getDiskStoreName: " + store.getDiskStoreName() + " and expected getDiskStoreName: mydisk", store.getDiskStoreName()== "mydisk");
         assertTrue("Mismatch in attributes, actual.HDFSStoreName: " + r1.getAttributes().getHDFSStoreName() + " and expected getDiskStoreName: myHDFSStore", r1.getAttributes().getHDFSStoreName()== "myHDFSStore");
         assertTrue("Mismatch in attributes, actual.getFolderPath: " + ((GemFireCacheImpl)this.c).findHDFSStore("myHDFSStore").getHomeDir() + " and expected getDiskStoreName: /home/hemant", ((GemFireCacheImpl)this.c).findHDFSStore("myHDFSStore").getHomeDir()== "/home/hemant");
         assertTrue("Mismatch in attributes, actual.getNamenode: " + ((GemFireCacheImpl)this.c).findHDFSStore("myHDFSStore").getNameNodeURL()+ " and expected getDiskStoreName: mymachine", ((GemFireCacheImpl)this.c).findHDFSStore("myHDFSStore").getNameNodeURL()== "mymachine");
-        assertTrue("Mismatch in attributes, actual.batchInterval: " + store.getHDFSEventQueueAttributes().getBatchTimeInterval() + " and expected batchsize: 50 ", store.getHDFSEventQueueAttributes().getBatchSizeMB()== 50);
-        assertTrue("Mismatch in attributes, actual.isDiskSynchronous: " + store.getHDFSEventQueueAttributes().isDiskSynchronous() + " and expected isPersistent: false", store.getHDFSEventQueueAttributes().isDiskSynchronous()== false);
-        assertTrue("Mismatch in attributes, actual.getFileRolloverInterval: " + store.getFileRolloverInterval() + " and expected getFileRolloverInterval: 10", store.getFileRolloverInterval() == 10);
-        assertTrue("Mismatch in attributes, actual.getMaxFileSize: " + store.getMaxFileSize() + " and expected getMaxFileSize: 1MB", store.getMaxFileSize() == 1);
+        assertTrue("Mismatch in attributes, actual.batchInterval: " + store.getBatchInterval() + " and expected batchsize: 50 ", store.getBatchSize()== 50);
+        assertTrue("Mismatch in attributes, actual.isDiskSynchronous: " + store.getSynchronousDiskWrite() + " and expected isPersistent: false", store.getSynchronousDiskWrite()== false);
+        assertTrue("Mismatch in attributes, actual.getFileRolloverInterval: " + store.getWriteOnlyFileRolloverInterval() + " and expected getFileRolloverInterval: 10", store.getWriteOnlyFileRolloverInterval() == 10);
+        assertTrue("Mismatch in attributes, actual.getMaxFileSize: " + store.getMaxWriteOnlyFileSize() + " and expected getMaxFileSize: 1MB", store.getMaxWriteOnlyFileSize() == 1);
         this.c.close();
       } finally {
         this.c.close();
@@ -190,12 +182,12 @@ public class HDFSConfigJUnitTest extends TestCase {
         r1 = this.c.getRegion("/r1");
         HDFSStoreImpl store = c.findHDFSStore(r1.getAttributes().getHDFSStoreName());
         r1.put("k1", "v1");
-        assertTrue("Mismatch in attributes, actual.batchsize: " + store.getHDFSEventQueueAttributes().getBatchSizeMB() + " and expected batchsize: 32", store.getHDFSEventQueueAttributes().getBatchSizeMB()== 32);
-        assertTrue("Mismatch in attributes, actual.isPersistent: " + store.getHDFSEventQueueAttributes().isPersistent() + " and expected isPersistent: false", store.getHDFSEventQueueAttributes().isPersistent()== false);
+        assertTrue("Mismatch in attributes, actual.batchsize: " + store.getBatchSize() + " and expected batchsize: 32", store.getBatchSize()== 32);
+        assertTrue("Mismatch in attributes, actual.isPersistent: " + store.getBufferPersistent() + " and expected isPersistent: false", store.getBufferPersistent()== false);
         assertEquals(false, r1.getAttributes().getHDFSWriteOnly());
-        assertTrue("Mismatch in attributes, actual.getDiskStoreName: " + store.getHDFSEventQueueAttributes().getDiskStoreName() + " and expected getDiskStoreName: null", store.getHDFSEventQueueAttributes().getDiskStoreName()== null);
-        assertTrue("Mismatch in attributes, actual.getFileRolloverInterval: " + store.getFileRolloverInterval() + " and expected getFileRolloverInterval: 3600", store.getFileRolloverInterval() == 3600);
-        assertTrue("Mismatch in attributes, actual.getMaxFileSize: " + store.getMaxFileSize() + " and expected getMaxFileSize: 256MB", store.getMaxFileSize() == 256);
+        assertTrue("Mismatch in attributes, actual.getDiskStoreName: " + store.getDiskStoreName() + " and expected getDiskStoreName: null", store.getDiskStoreName()== null);
+        assertTrue("Mismatch in attributes, actual.getFileRolloverInterval: " + store.getWriteOnlyFileRolloverInterval() + " and expected getFileRolloverInterval: 3600", store.getWriteOnlyFileRolloverInterval() == 3600);
+        assertTrue("Mismatch in attributes, actual.getMaxFileSize: " + store.getMaxWriteOnlyFileSize() + " and expected getMaxFileSize: 256MB", store.getMaxWriteOnlyFileSize() == 256);
         
         this.c.close();
         
@@ -225,10 +217,10 @@ public class HDFSConfigJUnitTest extends TestCase {
         r1 = this.c.getRegion("/r1");
         store = c.findHDFSStore(r1.getAttributes().getHDFSStoreName());
         r1.put("k1", "v1");
-        assertTrue("Mismatch in attributes, actual.batchsize: " + store.getHDFSEventQueueAttributes().getBatchSizeMB() + " and expected batchsize: 32", store.getHDFSEventQueueAttributes().getBatchSizeMB()== 32);
-        assertTrue("Mismatch in attributes, actual.isPersistent: " + store.getHDFSEventQueueAttributes().isPersistent() + " and expected isPersistent: false", store.getHDFSEventQueueAttributes().isPersistent()== false);
+        assertTrue("Mismatch in attributes, actual.batchsize: " + store.getBatchSize() + " and expected batchsize: 32", store.getBatchSize()== 32);
+        assertTrue("Mismatch in attributes, actual.isPersistent: " + store.getBufferPersistent() + " and expected isPersistent: false", store.getBufferPersistent()== false);
         assertTrue("Mismatch in attributes, actual.isRandomAccessAllowed: " + r1.getAttributes().getHDFSWriteOnly() + " and expected isRandomAccessAllowed: false", r1.getAttributes().getHDFSWriteOnly()== false);
-        assertTrue("Mismatch in attributes, actual.getDiskStoreName: " + store.getHDFSEventQueueAttributes().getDiskStoreName() + " and expected getDiskStoreName: null", store.getHDFSEventQueueAttributes().getDiskStoreName()== null);
+        assertTrue("Mismatch in attributes, actual.getDiskStoreName: " + store.getDiskStoreName() + " and expected getDiskStoreName: null", store.getDiskStoreName()== null);
         
         this.c.close();
         
@@ -263,17 +255,17 @@ public class HDFSConfigJUnitTest extends TestCase {
         r1 = this.c.getRegion("/r1");
         store = c.findHDFSStore(r1.getAttributes().getHDFSStoreName());
         r1.put("k1", "v1");
-        assertTrue("Mismatch in attributes, actual.batchsize: " + store.getHDFSEventQueueAttributes().getBatchSizeMB() + " and expected batchsize: 151", store.getHDFSEventQueueAttributes().getBatchSizeMB()== 151);
-        assertTrue("Mismatch in attributes, actual.isPersistent: " + store.getHDFSEventQueueAttributes().isPersistent() + " and expected isPersistent: true", store.getHDFSEventQueueAttributes().isPersistent()== true);
+        assertTrue("Mismatch in attributes, actual.batchsize: " + store.getBatchSize() + " and expected batchsize: 151", store.getBatchSize()== 151);
+        assertTrue("Mismatch in attributes, actual.isPersistent: " + store.getBufferPersistent() + " and expected isPersistent: true", store.getBufferPersistent()== true);
         assertTrue("Mismatch in attributes, actual.isRandomAccessAllowed: " + r1.getAttributes().getHDFSWriteOnly() + " and expected isRandomAccessAllowed: true", r1.getAttributes().getHDFSWriteOnly()== false);
-        assertTrue("Mismatch in attributes, actual.getDiskStoreName: " + store.getHDFSEventQueueAttributes().getDiskStoreName() + " and expected getDiskStoreName: mydiskstore", store.getHDFSEventQueueAttributes().getDiskStoreName().equals("mydiskstore"));
+        assertTrue("Mismatch in attributes, actual.getDiskStoreName: " + store.getDiskStoreName() + " and expected getDiskStoreName: mydiskstore", store.getDiskStoreName().equals("mydiskstore"));
         assertTrue("Mismatch in attributes, actual.HDFSStoreName: " + r1.getAttributes().getHDFSStoreName() + " and expected getDiskStoreName: myHDFSStore", r1.getAttributes().getHDFSStoreName().equals("myHDFSStore"));
         assertTrue("Mismatch in attributes, actual.getFolderPath: " + ((GemFireCacheImpl)this.c).findHDFSStore("myHDFSStore").getHomeDir() + " and expected getDiskStoreName: mypath", ((GemFireCacheImpl)this.c).findHDFSStore("myHDFSStore").getHomeDir().equals("mypath"));
         assertTrue("Mismatch in attributes, actual.getNamenode: " + ((GemFireCacheImpl)this.c).findHDFSStore("myHDFSStore").getNameNodeURL()+ " and expected getDiskStoreName: mynamenode", ((GemFireCacheImpl)this.c).findHDFSStore("myHDFSStore").getNameNodeURL().equals("mynamenode"));
-        assertTrue("Mismatch in attributes, actual.batchInterval: " + store.getHDFSEventQueueAttributes().getBatchTimeInterval() + " and expected batchsize: 50", store.getHDFSEventQueueAttributes().getBatchTimeInterval()== 50);
-        assertTrue("Mismatch in attributes, actual.isDiskSynchronous: " + store.getHDFSEventQueueAttributes().isDiskSynchronous() + " and expected isDiskSynchronous: false", store.getHDFSEventQueueAttributes().isDiskSynchronous()== false);
-        assertTrue("Mismatch in attributes, actual.getFileRolloverInterval: " + store.getFileRolloverInterval() + " and expected getFileRolloverInterval: 10", store.getFileRolloverInterval() == 10);
-        assertTrue("Mismatch in attributes, actual.getMaxFileSize: " + store.getMaxFileSize() + " and expected getMaxFileSize: 1MB", store.getMaxFileSize() == 1);
+        assertTrue("Mismatch in attributes, actual.batchInterval: " + store.getBatchInterval() + " and expected batchsize: 50", store.getBatchInterval()== 50);
+        assertTrue("Mismatch in attributes, actual.isDiskSynchronous: " + store.getSynchronousDiskWrite() + " and expected isDiskSynchronous: false", store.getSynchronousDiskWrite()== false);
+        assertTrue("Mismatch in attributes, actual.getFileRolloverInterval: " + store.getWriteOnlyFileRolloverInterval() + " and expected getFileRolloverInterval: 10", store.getWriteOnlyFileRolloverInterval() == 10);
+        assertTrue("Mismatch in attributes, actual.getMaxFileSize: " + store.getMaxWriteOnlyFileSize() + " and expected getMaxFileSize: 1MB", store.getMaxWriteOnlyFileSize() == 1);
         
         this.c.close();
       } finally {
@@ -293,13 +285,11 @@ public class HDFSConfigJUnitTest extends TestCase {
     assertEquals("hdfs-client-config-file mismatch.", "client", store.getHDFSClientConfigFile());
     assertEquals("read-cache-size mismatch.", 24.5f, store.getBlockCacheSize());
     
-    HDFSCompactionConfig compactConf = store.getHDFSCompactionConfig();
-    assertEquals("compaction strategy mismatch.", "size-oriented", compactConf.getCompactionStrategy());
     assertFalse("compaction auto-compact mismatch.", store.getMinorCompaction());
-    assertTrue("compaction auto-major-compact mismatch.", compactConf.getAutoMajorCompaction());
-    assertEquals("compaction max-concurrency", 23, compactConf.getMaxThreads());
-    assertEquals("compaction max-major-concurrency", 27, compactConf.getMajorCompactionMaxThreads());
-    assertEquals("compaction major-interval", 711, compactConf.getOldFilesCleanupIntervalMins());
+    assertTrue("compaction auto-major-compact mismatch.", store.getMajorCompaction());
+    assertEquals("compaction max-concurrency", 23, store.getMinorCompactionThreads());
+    assertEquals("compaction max-major-concurrency", 27, store.getMajorCompactionThreads());
+    assertEquals("compaction major-interval", 711, store.getPurgeInterval());
   }
   
   /**
@@ -311,18 +301,15 @@ public class HDFSConfigJUnitTest extends TestCase {
     assertEquals("namenode url mismatch.", "url", store.getNameNodeURL());
     assertEquals("home-dir mismatch.", "gemfire", store.getHomeDir());
     
-    HDFSCompactionConfig compactConf = store.getHDFSCompactionConfig();
-    assertNotNull("compaction conf should have initialized to default", compactConf);
-    assertEquals("compaction strategy mismatch.", "size-oriented", compactConf.getCompactionStrategy());
     assertTrue("compaction auto-compact mismatch.", store.getMinorCompaction());
-    assertTrue("compaction auto-major-compact mismatch.", compactConf.getAutoMajorCompaction());
-    assertEquals("compaction max-input-file-size mismatch.", 512, compactConf.getMaxInputFileSizeMB());
-    assertEquals("compaction min-input-file-count.", 4, compactConf.getMinInputFileCount());
-    assertEquals("compaction max-iteration-size.", 10, compactConf.getMaxInputFileCount());
-    assertEquals("compaction max-concurrency", 10, compactConf.getMaxThreads());
-    assertEquals("compaction max-major-concurrency", 2, compactConf.getMajorCompactionMaxThreads());
-    assertEquals("compaction major-interval", 720, compactConf.getMajorCompactionIntervalMins());
-    assertEquals("compaction cleanup-interval", 30, compactConf.getOldFilesCleanupIntervalMins());
+    assertTrue("compaction auto-major-compact mismatch.", store.getMajorCompaction());
+    assertEquals("compaction max-input-file-size mismatch.", 512, store.getMaxInputFileSizeMB());
+    assertEquals("compaction min-input-file-count.", 4, store.getMinInputFileCount());
+    assertEquals("compaction max-iteration-size.", 10, store.getMaxInputFileCount());
+    assertEquals("compaction max-concurrency", 10, store.getMinorCompactionThreads());
+    assertEquals("compaction max-major-concurrency", 2, store.getMajorCompactionThreads());
+    assertEquals("compaction major-interval", 720, store.getMajorCompactionInterval());
+    assertEquals("compaction cleanup-interval", 30, store.getPurgeInterval());
   }
   
   /**
@@ -350,62 +337,61 @@ public class HDFSConfigJUnitTest extends TestCase {
 
     HDFSStoreFactory hsf; 
     hsf = this.c.createHDFSStoreFactory();
-    HDFSCompactionConfigFactory ccsf = hsf.createCompactionConfigFactory(null);
     
     try {
-      ccsf.setMaxInputFileSizeMB(-1);
+      hsf.setMaxInputFileSizeMB(-1);
       fail("validation failed");
     } catch (IllegalArgumentException e) {
       //expected
     }
     try {
-      ccsf.setMinInputFileCount(-1);
+      hsf.setMinInputFileCount(-1);
       fail("validation failed");
     } catch (IllegalArgumentException e) {
       //expected
     }
     try {
-      ccsf.setMaxInputFileCount(-1);
+      hsf.setMaxInputFileCount(-1);
       //expected
       fail("validation failed");
     } catch (IllegalArgumentException e) {
     }
     try {
-      ccsf.setMaxThreads(-1);
+      hsf.setMinorCompactionThreads(-1);
       fail("validation failed");
     } catch (IllegalArgumentException e) {
       //expected
     }
     try {
-      ccsf.setMajorCompactionIntervalMins(-1);
+      hsf.setMajorCompactionInterval(-1);
       fail("validation failed");
     } catch (IllegalArgumentException e) {
       //expected
     }
     try {
-      ccsf.setMajorCompactionMaxThreads(-1);
+      hsf.setMajorCompactionThreads(-1);
       fail("validation failed");
     } catch (IllegalArgumentException e) {
       //expected
     }
     try {
-      ccsf.setOldFilesCleanupIntervalMins(-1);
+      hsf.setPurgeInterval(-1);
       fail("validation failed");
     } catch (IllegalArgumentException e) {
       //expected
     }
     try {
-      ccsf.setMinInputFileCount(2);
-      ccsf.setMaxInputFileCount(1);
-      ccsf.create();
+      hsf.setMinInputFileCount(2);
+      hsf.setMaxInputFileCount(1);
+      hsf.create("test");
       fail("validation failed");
     } catch (IllegalArgumentException e) {
       //expected
     }
     try {
-      ccsf.setMaxInputFileCount(1);
-      ccsf.setMinInputFileCount(2);
-      ccsf.create();
+      hsf.setMaxInputFileCount(1);
+      hsf.setMinInputFileCount(2);
+      hsf.create("test");
       fail("validation failed");
     } catch (IllegalArgumentException e) {
       //expected
@@ -483,8 +469,6 @@ public class HDFSConfigJUnitTest extends TestCase {
       HDFSStoreImpl store = (HDFSStoreImpl) hsf.create("myHDFSStore");
       RegionFactory rf1 = this.c.createRegionFactory(RegionShortcut.PARTITION_HDFS);
       //Create a region that evicts everything
-      HDFSEventQueueAttributesFactory heqf = new HDFSEventQueueAttributesFactory();
-      heqf.setBatchTimeInterval(10);
       LocalRegion r1 = (LocalRegion) rf1.setHDFSStoreName("myHDFSStore").setEvictionAttributes(EvictionAttributes.createLRUEntryAttributes(1)).create("r1");
      
       //Populate about many times our block cache size worth of data

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/3772869d/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/HdfsStoreMutatorJUnitTest.java
----------------------------------------------------------------------
diff --git a/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/HdfsStoreMutatorJUnitTest.java b/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/HdfsStoreMutatorJUnitTest.java
index f12078e..f936b43 100644
--- a/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/HdfsStoreMutatorJUnitTest.java
+++ b/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/HdfsStoreMutatorJUnitTest.java
@@ -10,94 +10,87 @@ package com.gemstone.gemfire.cache.hdfs.internal;
 import org.junit.experimental.categories.Category;
 
 import com.gemstone.gemfire.cache.hdfs.HDFSStoreMutator;
-import com.gemstone.gemfire.cache.hdfs.HDFSStoreMutator.HDFSCompactionConfigMutator;
-import com.gemstone.gemfire.cache.hdfs.HDFSStoreMutator.HDFSEventQueueAttributesMutator;
 import com.gemstone.gemfire.cache.hdfs.internal.hoplog.BaseHoplogTestCase;
 import com.gemstone.gemfire.test.junit.categories.HoplogTest;
-import com.gemstone.gemfire.test.junit.categories.IntegrationTest
-;
+import com.gemstone.gemfire.test.junit.categories.IntegrationTest;
 
 @Category({IntegrationTest.class, HoplogTest.class})
 public class HdfsStoreMutatorJUnitTest extends BaseHoplogTestCase {
   public void testMutatorInitialState() {
     HDFSStoreMutator mutator = hdfsStore.createHdfsStoreMutator();
-    assertEquals(-1, mutator.getFileRolloverInterval());
-    assertEquals(-1, mutator.getMaxFileSize());
-    
-    HDFSCompactionConfigMutator compMutator = mutator.getCompactionConfigMutator();
-    assertEquals(-1, compMutator.getMaxInputFileCount());
-    assertEquals(-1, compMutator.getMaxInputFileSizeMB());
-    assertEquals(-1, compMutator.getMinInputFileCount());
-    assertEquals(-1, compMutator.getMaxThreads());
+    assertEquals(-1, mutator.getWriteOnlyFileRolloverInterval());
+    assertEquals(-1, mutator.getMaxWriteOnlyFileSize());
+    
+    assertEquals(-1, mutator.getMaxInputFileCount());
+    assertEquals(-1, mutator.getMaxInputFileSizeMB());
+    assertEquals(-1, mutator.getMinInputFileCount());
+    assertEquals(-1, mutator.getMinorCompactionThreads());
     assertNull(mutator.getMinorCompaction());
     
-    assertEquals(-1, compMutator.getMajorCompactionIntervalMins());
-    assertEquals(-1, compMutator.getMajorCompactionMaxThreads());
-    assertNull(compMutator.getAutoMajorCompaction());
+    assertEquals(-1, mutator.getMajorCompactionInterval());
+    assertEquals(-1, mutator.getMajorCompactionThreads());
+    assertNull(mutator.getMajorCompaction());
     
-    assertEquals(-1, compMutator.getOldFilesCleanupIntervalMins());
+    assertEquals(-1, mutator.getPurgeInterval());
     
-    HDFSEventQueueAttributesMutator qMutator = mutator.getHDFSEventQueueAttributesMutator();
-    assertEquals(-1, qMutator.getBatchSizeMB());
-    assertEquals(-1, qMutator.getBatchTimeInterval());
+    assertEquals(-1, mutator.getBatchSize());
+    assertEquals(-1, mutator.getBatchInterval());
   }
   
   public void testMutatorSetInvalidValue() {
     HDFSStoreMutator mutator = hdfsStore.createHdfsStoreMutator();
-    HDFSCompactionConfigMutator compMutator = mutator.getCompactionConfigMutator();
-    HDFSEventQueueAttributesMutator qMutator = mutator.getHDFSEventQueueAttributesMutator();
 
     try {
-      mutator.setFileRolloverInterval(-3);
+      mutator.setWriteOnlyFileRolloverInterval(-3);
       fail();
     } catch (IllegalArgumentException e) {
       // expected
     }
     try {
-      mutator.setMaxFileSize(-5);
+      mutator.setMaxWriteOnlyFileSize(-5);
       fail();
     } catch (IllegalArgumentException e) {
       // expected
     }
     
     try {
-      compMutator.setMinInputFileCount(-1);
+      mutator.setMinInputFileCount(-1);
       fail();
     } catch (IllegalArgumentException e) {
       // expected
     }
     try {
-      compMutator.setMaxInputFileCount(-1);
+      mutator.setMaxInputFileCount(-1);
       fail();
     } catch (IllegalArgumentException e) {
       // expected
     }
     try {
-      compMutator.setMaxInputFileSizeMB(-1);
+      mutator.setMaxInputFileSizeMB(-1);
       fail();
     } catch (IllegalArgumentException e) {
       // expected
     }
     try {
-      compMutator.setMaxThreads(-9);
+      mutator.setMinorCompactionThreads(-9);
       fail();
     } catch (IllegalArgumentException e) {
       // expected
     }
     try {
-      compMutator.setMajorCompactionIntervalMins(-6);
+      mutator.setMajorCompactionInterval(-6);
       fail();
     } catch (IllegalArgumentException e) {
       // expected
     }
     try {
-      compMutator.setMajorCompactionMaxThreads(-1);
+      mutator.setMajorCompactionThreads(-1);
       fail();
     } catch (IllegalArgumentException e) {
       // expected
     }
     try {
-      compMutator.setOldFilesCleanupIntervalMins(-4);
+      mutator.setPurgeInterval(-4);
       fail();
     } catch (IllegalArgumentException e) {
       // expected
@@ -116,8 +109,8 @@ public class HdfsStoreMutatorJUnitTest extends BaseHoplogTestCase {
     }
 */    
     try {
-      compMutator.setMinInputFileCount(10);
-      compMutator.setMaxInputFileCount(5);
+      mutator.setMinInputFileCount(10);
+      mutator.setMaxInputFileCount(5);
       hdfsStore.alter(mutator);
       fail();
     } catch (IllegalArgumentException e) {
@@ -127,74 +120,72 @@ public class HdfsStoreMutatorJUnitTest extends BaseHoplogTestCase {
   
   public void testMutatorReturnsUpdatedValues() {
     HDFSStoreMutator mutator = hdfsStore.createHdfsStoreMutator();
-    HDFSCompactionConfigMutator compMutator = mutator.getCompactionConfigMutator();
-    HDFSEventQueueAttributesMutator qMutator = mutator.getHDFSEventQueueAttributesMutator();
     
-    mutator.setFileRolloverInterval(121);
-    mutator.setMaxFileSize(234);
+    mutator.setWriteOnlyFileRolloverInterval(121);
+    mutator.setMaxWriteOnlyFileSize(234);
     
-    compMutator.setMaxInputFileCount(87);
-    compMutator.setMaxInputFileSizeMB(45);
-    compMutator.setMinInputFileCount(34);
-    compMutator.setMaxThreads(843);
+    mutator.setMaxInputFileCount(87);
+    mutator.setMaxInputFileSizeMB(45);
+    mutator.setMinInputFileCount(34);
+    mutator.setMinorCompactionThreads(843);
     mutator.setMinorCompaction(false);
 
-    compMutator.setMajorCompactionIntervalMins(26);
-    compMutator.setMajorCompactionMaxThreads(92);
-    compMutator.setAutoMajorCompaction(false);
+    mutator.setMajorCompactionInterval(26);
+    mutator.setMajorCompactionThreads(92);
+    mutator.setMajorCompaction(false);
     
-    compMutator.setOldFilesCleanupIntervalMins(328);
+    mutator.setPurgeInterval(328);
     
-    qMutator.setBatchSizeMB(985);
-    qMutator.setBatchTimeInterval(695);
+    mutator.setBatchSize(985);
+    mutator.setBatchInterval(695);
     
-    assertEquals(121, mutator.getFileRolloverInterval());
-    assertEquals(234, mutator.getMaxFileSize());
+    assertEquals(121, mutator.getWriteOnlyFileRolloverInterval());
+    assertEquals(234, mutator.getMaxWriteOnlyFileSize());
     
-    assertEquals(87, compMutator.getMaxInputFileCount());
-    assertEquals(45, compMutator.getMaxInputFileSizeMB());
-    assertEquals(34, compMutator.getMinInputFileCount());
-    assertEquals(843, compMutator.getMaxThreads());
+    assertEquals(87, mutator.getMaxInputFileCount());
+    assertEquals(45, mutator.getMaxInputFileSizeMB());
+    assertEquals(34, mutator.getMinInputFileCount());
+    assertEquals(843, mutator.getMinorCompactionThreads());
     assertFalse(mutator.getMinorCompaction());
     
-    assertEquals(26, compMutator.getMajorCompactionIntervalMins());
-    assertEquals(92, compMutator.getMajorCompactionMaxThreads());
-    assertFalse(compMutator.getAutoMajorCompaction());
+    assertEquals(26, mutator.getMajorCompactionInterval());
+    assertEquals(92, mutator.getMajorCompactionThreads());
+    assertFalse(mutator.getMajorCompaction());
     
-    assertEquals(328, compMutator.getOldFilesCleanupIntervalMins());
+    assertEquals(328, mutator.getPurgeInterval());
     
-    assertEquals(985, qMutator.getBatchSizeMB());
-    assertEquals(695, qMutator.getBatchTimeInterval());
+    assertEquals(985, mutator.getBatchSize());
+    assertEquals(695, mutator.getBatchInterval());
     
     // repeat the cycle once more
-    mutator.setFileRolloverInterval(14);
-    mutator.setMaxFileSize(56);
+    mutator.setWriteOnlyFileRolloverInterval(14);
+    mutator.setMaxWriteOnlyFileSize(56);
     
-    compMutator.setMaxInputFileCount(93);
-    compMutator.setMaxInputFileSizeMB(85);
-    compMutator.setMinInputFileCount(64);
-    compMutator.setMaxThreads(59);
+    mutator.setMaxInputFileCount(93);
+    mutator.setMaxInputFileSizeMB(85);
+    mutator.setMinInputFileCount(64);
+    mutator.setMinorCompactionThreads(59);
     mutator.setMinorCompaction(true);
     
-    compMutator.setMajorCompactionIntervalMins(26);
-    compMutator.setMajorCompactionMaxThreads(92);
-    compMutator.setAutoMajorCompaction(false);
+    mutator.setMajorCompactionInterval(26);
+    mutator.setMajorCompactionThreads(92);
+    mutator.setMajorCompaction(false);
     
-    compMutator.setOldFilesCleanupIntervalMins(328);
+    mutator.setPurgeInterval(328);
     
-    assertEquals(14, mutator.getFileRolloverInterval());
-    assertEquals(56, mutator.getMaxFileSize());
+    assertEquals(14, mutator.getWriteOnlyFileRolloverInterval());
+    assertEquals(56, mutator.getMaxWriteOnlyFileSize());
     
-    assertEquals(93, compMutator.getMaxInputFileCount());
-    assertEquals(85, compMutator.getMaxInputFileSizeMB());
-    assertEquals(64, compMutator.getMinInputFileCount());
-    assertEquals(59, compMutator.getMaxThreads());
+    assertEquals(93, mutator.getMaxInputFileCount());
+    assertEquals(85, mutator.getMaxInputFileSizeMB());
+    assertEquals(64, mutator.getMinInputFileCount());
+    assertEquals(59, mutator.getMinorCompactionThreads());
     assertTrue(mutator.getMinorCompaction());
     
-    assertEquals(26, compMutator.getMajorCompactionIntervalMins());
-    assertEquals(92, compMutator.getMajorCompactionMaxThreads());
-    assertFalse(compMutator.getAutoMajorCompaction());
+    assertEquals(26, mutator.getMajorCompactionInterval());
+    assertEquals(92, mutator.getMajorCompactionThreads());
+    assertFalse(mutator.getMajorCompaction());
     
-    assertEquals(328, compMutator.getOldFilesCleanupIntervalMins());
+    assertEquals(328, mutator.getPurgeInterval());
   }
 }

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/3772869d/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/hoplog/BaseHoplogTestCase.java
----------------------------------------------------------------------
diff --git a/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/hoplog/BaseHoplogTestCase.java b/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/hoplog/BaseHoplogTestCase.java
index 06c3c4b..eb713c0 100644
--- a/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/hoplog/BaseHoplogTestCase.java
+++ b/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/hoplog/BaseHoplogTestCase.java
@@ -37,7 +37,6 @@ import com.gemstone.gemfire.cache.SerializedCacheValue;
 import com.gemstone.gemfire.cache.TransactionId;
 import com.gemstone.gemfire.cache.hdfs.HDFSStore;
 import com.gemstone.gemfire.cache.hdfs.HDFSStoreFactory;
-import com.gemstone.gemfire.cache.hdfs.HDFSStoreFactory.HDFSCompactionConfigFactory;
 import com.gemstone.gemfire.cache.hdfs.HDFSStoreMutator;
 import com.gemstone.gemfire.cache.hdfs.internal.HDFSStoreFactoryImpl;
 import com.gemstone.gemfire.cache.hdfs.internal.HDFSStoreImpl;
@@ -110,10 +109,8 @@ public abstract class BaseHoplogTestCase extends TestCase {
   protected void configureHdfsStoreFactory() throws Exception {
     hsf = this.cache.createHDFSStoreFactory();
     hsf.setHomeDir(testDataDir.toString());
-    HDFSCompactionConfigFactory cc = hsf.createCompactionConfigFactory(null);
     hsf.setMinorCompaction(false);
-    cc.setAutoMajorCompaction(false);
-    hsf.setHDFSCompactionConfig(cc.create());
+    hsf.setMajorCompaction(false);
   }
 
   protected Cache createCache() {
@@ -219,7 +216,7 @@ public abstract class BaseHoplogTestCase extends TestCase {
   
   public static void alterMajorCompaction(HDFSStoreImpl store, boolean enable) {
     HDFSStoreMutator mutator = store.createHdfsStoreMutator();
-    mutator.getCompactionConfigMutator().setAutoMajorCompaction(enable);
+    mutator.setMajorCompaction(enable);
     store.alter(mutator);
   }
   

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/3772869d/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/hoplog/HDFSCacheLoaderJUnitTest.java
----------------------------------------------------------------------
diff --git a/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/hoplog/HDFSCacheLoaderJUnitTest.java b/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/hoplog/HDFSCacheLoaderJUnitTest.java
index 3e4b8e2..67dcddf 100644
--- a/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/hoplog/HDFSCacheLoaderJUnitTest.java
+++ b/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/hoplog/HDFSCacheLoaderJUnitTest.java
@@ -19,7 +19,6 @@ import com.gemstone.gemfire.cache.asyncqueue.AsyncEventListener;
 import com.gemstone.gemfire.cache.asyncqueue.internal.AsyncEventQueueFactoryImpl;
 import com.gemstone.gemfire.cache.asyncqueue.internal.AsyncEventQueueImpl;
 import com.gemstone.gemfire.cache.asyncqueue.internal.AsyncEventQueueStats;
-import com.gemstone.gemfire.cache.hdfs.HDFSEventQueueAttributesFactory;
 import com.gemstone.gemfire.test.junit.categories.HoplogTest;
 import com.gemstone.gemfire.test.junit.categories.IntegrationTest
 ;
@@ -36,7 +35,8 @@ public class HDFSCacheLoaderJUnitTest extends BaseHoplogTestCase {
   protected void configureHdfsStoreFactory() throws Exception {
     hsf = this.cache.createHDFSStoreFactory();
     hsf.setHomeDir(testDataDir.toString());
-    hsf.setHDFSEventQueueAttributes(new HDFSEventQueueAttributesFactory().setBatchTimeInterval(100000000).setBatchSizeMB(10000).create());
+    hsf.setBatchInterval(100000000);
+    hsf.setBatchSize(10000);
   }
 
   /**

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/3772869d/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/hoplog/HDFSCompactionManagerJUnitTest.java
----------------------------------------------------------------------
diff --git a/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/hoplog/HDFSCompactionManagerJUnitTest.java b/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/hoplog/HDFSCompactionManagerJUnitTest.java
index 2c32d61..011d82b 100644
--- a/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/hoplog/HDFSCompactionManagerJUnitTest.java
+++ b/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/hoplog/HDFSCompactionManagerJUnitTest.java
@@ -382,15 +382,15 @@ public class HDFSCompactionManagerJUnitTest extends BaseHoplogTestCase {
     if (testMajor) {
       alterMajorCompaction(hdfsStore, true);
       defaultThreadCount = 2;
-      mutator.getCompactionConfigMutator().setMajorCompactionMaxThreads(15);
+      mutator.setMajorCompactionThreads(15);
       if (decrease) {
-        mutator.getCompactionConfigMutator().setMajorCompactionMaxThreads(1);
+        mutator.setMajorCompactionThreads(1);
       }
     } else {
       alterMinorCompaction(hdfsStore, true);
-      mutator.getCompactionConfigMutator().setMaxThreads(15);
+      mutator.setMinorCompactionThreads(15);
       if (decrease) {
-        mutator.getCompactionConfigMutator().setMaxThreads(1);
+        mutator.setMinorCompactionThreads(1);
       }
     }
     

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/3772869d/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/hoplog/HDFSUnsortedHoplogOrganizerJUnitTest.java
----------------------------------------------------------------------
diff --git a/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/hoplog/HDFSUnsortedHoplogOrganizerJUnitTest.java b/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/hoplog/HDFSUnsortedHoplogOrganizerJUnitTest.java
index 8d2fae3..ab1ccac 100644
--- a/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/hoplog/HDFSUnsortedHoplogOrganizerJUnitTest.java
+++ b/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/hoplog/HDFSUnsortedHoplogOrganizerJUnitTest.java
@@ -83,7 +83,7 @@ public class HDFSUnsortedHoplogOrganizerJUnitTest extends BaseHoplogTestCase {
     readSequenceFile(hdfsStore.getFileSystem(), hoplogs[0].getPath(), 0);
     
     HDFSStoreMutator mutator = hdfsStore.createHdfsStoreMutator();
-    mutator.setFileRolloverInterval(1);
+    mutator.setWriteOnlyFileRolloverInterval(1);
     hdfsStore.alter(mutator);
     
     TimeUnit.MILLISECONDS.sleep(1100);

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/3772869d/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/hoplog/HdfsSortedOplogOrganizerJUnitTest.java
----------------------------------------------------------------------
diff --git a/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/hoplog/HdfsSortedOplogOrganizerJUnitTest.java b/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/hoplog/HdfsSortedOplogOrganizerJUnitTest.java
index 0884a40..4529067 100644
--- a/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/hoplog/HdfsSortedOplogOrganizerJUnitTest.java
+++ b/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/hoplog/HdfsSortedOplogOrganizerJUnitTest.java
@@ -29,7 +29,7 @@ import org.junit.experimental.categories.Category;
 
 import com.gemstone.gemfire.cache.Region;
 import com.gemstone.gemfire.cache.hdfs.HDFSIOException;
-import com.gemstone.gemfire.cache.hdfs.HDFSStore.HDFSCompactionConfig;
+import com.gemstone.gemfire.cache.hdfs.HDFSStore;
 import com.gemstone.gemfire.cache.hdfs.HDFSStoreMutator;
 import com.gemstone.gemfire.cache.hdfs.internal.PersistedEventImpl;
 import com.gemstone.gemfire.cache.hdfs.internal.SortedHoplogPersistedEvent;
@@ -418,7 +418,7 @@ public class HdfsSortedOplogOrganizerJUnitTest extends BaseHoplogTestCase {
             markers.add(marker);
           }
           // inject a dummy old expiry marker for major compacted file
-          long age = 2 * HDFSCompactionConfig.DEFAULT_MAJOR_COMPACTION_INTERVAL_MINS * 60 * 1000;
+          long age = 2 * HDFSStore.DEFAULT_MAJOR_COMPACTION_INTERVAL_MINS * 60 * 1000;
           String markerName = "0-2-2222" + AbstractHoplogOrganizer.MAJOR_HOPLOG_EXTENSION + EXPIRED_HOPLOG_EXTENSION;
           FileStatus marker = new FileStatus(0, false, 1, 1024, System.currentTimeMillis() - age, new Path(bucketPath, markerName));
           markers.add(marker);
@@ -509,7 +509,7 @@ public class HdfsSortedOplogOrganizerJUnitTest extends BaseHoplogTestCase {
     assertEquals(0, count);
     
     HDFSStoreMutator mutator = hdfsStore.createHdfsStoreMutator();
-    mutator.getCompactionConfigMutator().setOldFilesCleanupIntervalMins(1);
+    mutator.setPurgeInterval(1);
     hdfsStore.alter(mutator);
     count = organizer.initiateCleanup();
     assertEquals(4, count);
@@ -727,7 +727,7 @@ public class HdfsSortedOplogOrganizerJUnitTest extends BaseHoplogTestCase {
       assertEquals(0, majorCReqCount.get());
     }
     HDFSStoreMutator mutator = hdfsStore.createHdfsStoreMutator();
-    mutator.getCompactionConfigMutator().setMajorCompactionIntervalMins(1);
+    mutator.setMajorCompactionInterval(1);
     hdfsStore.alter(mutator);
     TimeUnit.SECONDS.sleep(5);
     assertTrue(3 < majorCReqCount.get());
@@ -1031,7 +1031,7 @@ public class HdfsSortedOplogOrganizerJUnitTest extends BaseHoplogTestCase {
     FileSystem fs = hdfsStore.getFileSystem();
     Path cleanUpIntervalPath = new Path(hdfsStore.getHomeDir(), HoplogConfig.CLEAN_UP_INTERVAL_FILE_NAME);
     assertTrue(fs.exists(cleanUpIntervalPath));
-    long interval = HDFSCompactionConfig.DEFAULT_OLD_FILE_CLEANUP_INTERVAL_MINS
+    long interval = HDFSStore.DEFAULT_OLD_FILE_CLEANUP_INTERVAL_MINS
         *60 * 1000;
     assertEquals(interval, HoplogUtil.readCleanUpIntervalMillis(fs,cleanUpIntervalPath));
   }

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/3772869d/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/hoplog/TieredCompactionJUnitTest.java
----------------------------------------------------------------------
diff --git a/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/hoplog/TieredCompactionJUnitTest.java b/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/hoplog/TieredCompactionJUnitTest.java
index 007e73b..5bd258e 100644
--- a/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/hoplog/TieredCompactionJUnitTest.java
+++ b/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/hoplog/TieredCompactionJUnitTest.java
@@ -25,7 +25,6 @@ import org.junit.experimental.categories.Category;
 
 import com.gemstone.gemfire.cache.Operation;
 import com.gemstone.gemfire.cache.hdfs.HDFSStore;
-import com.gemstone.gemfire.cache.hdfs.HDFSStoreFactory.HDFSCompactionConfigFactory;
 import com.gemstone.gemfire.cache.hdfs.HDFSStoreMutator;
 import com.gemstone.gemfire.cache.hdfs.internal.HDFSStoreImpl;
 import com.gemstone.gemfire.cache.hdfs.internal.PersistedEventImpl;
@@ -49,11 +48,9 @@ public class TieredCompactionJUnitTest extends BaseHoplogTestCase {
   protected void configureHdfsStoreFactory() throws Exception {
     super.configureHdfsStoreFactory();
     
-    HDFSCompactionConfigFactory factory = hsf.createCompactionConfigFactory(null);
-    factory.setMinInputFileCount(3);
+    hsf.setMinInputFileCount(3);
     hsf.setMinorCompaction(false);
-    factory.setAutoMajorCompaction(false);
-    hsf.setHDFSCompactionConfig(factory.create());
+    hsf.setMajorCompaction(false);
   }
   
   public void testMinorCompaction() throws Exception {
@@ -349,7 +346,7 @@ public class TieredCompactionJUnitTest extends BaseHoplogTestCase {
     TestHoplog thirdHop = (TestHoplog) targets.get(2).get();
 
     // oldest is more than max size is ignored 
-    oldestHop.get().size = HDFSStore.HDFSCompactionConfig.DEFAULT_MAX_INPUT_FILE_SIZE_MB * ONE_MB + 100;
+    oldestHop.get().size = HDFSStore.DEFAULT_MAX_INPUT_FILE_SIZE_MB * ONE_MB + 100;
     List<TrackedReference<Hoplog>> list = (List<TrackedReference<Hoplog>>) targets.clone();
     compactor.getMinorCompactionTargets(list, -1);
     assertEquals(4, list.size());
@@ -358,7 +355,7 @@ public class TieredCompactionJUnitTest extends BaseHoplogTestCase {
     }
     
     // third is more than max size but is not ignored
-    thirdHop.size = HDFSStore.HDFSCompactionConfig.DEFAULT_MAX_INPUT_FILE_SIZE_MB * ONE_MB + 100;
+    thirdHop.size = HDFSStore.DEFAULT_MAX_INPUT_FILE_SIZE_MB * ONE_MB + 100;
     oldestHop.increment();
     list = (List<TrackedReference<Hoplog>>) targets.clone();
     compactor.getMinorCompactionTargets(list, -1);
@@ -368,7 +365,7 @@ public class TieredCompactionJUnitTest extends BaseHoplogTestCase {
       if (i != 2) {
         assertTrue(((TestHoplog) ref.get()).size - TEN_MB < 5);
       } else {
-        assertTrue(((TestHoplog) ref.get()).size > HDFSStore.HDFSCompactionConfig.DEFAULT_MAX_INPUT_FILE_SIZE_MB * ONE_MB);
+        assertTrue(((TestHoplog) ref.get()).size > HDFSStore.DEFAULT_MAX_INPUT_FILE_SIZE_MB * ONE_MB);
       }
       i++;
     }
@@ -378,7 +375,7 @@ public class TieredCompactionJUnitTest extends BaseHoplogTestCase {
     HdfsSortedOplogOrganizer organizer = new HdfsSortedOplogOrganizer(regionManager, 0);
     HoplogCompactor compactor = (HoplogCompactor) organizer.getCompactor();
 
-    assertTrue(TEN_MB * 2 < hdfsStore.getHDFSCompactionConfig().getMaxInputFileSizeMB() * ONE_MB);
+    assertTrue(TEN_MB * 2 < hdfsStore.getMaxInputFileSizeMB() * ONE_MB);
     
     ArrayList<TrackedReference<TestHoplog>> targets = new ArrayList<TrackedReference<TestHoplog>>();
     for (int i = 0; i < 5; i++) {
@@ -392,7 +389,7 @@ public class TieredCompactionJUnitTest extends BaseHoplogTestCase {
     assertEquals(targets.size(), list.size());
     
     HDFSStoreMutator mutator = hdfsStore.createHdfsStoreMutator();
-    mutator.getCompactionConfigMutator().setMaxInputFileSizeMB(1);
+    mutator.setMaxInputFileSizeMB(1);
     hdfsStore.alter(mutator);
     
     compactor.getMinorCompactionTargets(list, -1);
@@ -403,7 +400,7 @@ public class TieredCompactionJUnitTest extends BaseHoplogTestCase {
     HdfsSortedOplogOrganizer organizer = new HdfsSortedOplogOrganizer(regionManager, 0);
     HoplogCompactor compactor = (HoplogCompactor) organizer.getCompactor();
     
-    assertTrue(2 < hdfsStore.getHDFSCompactionConfig().getMaxInputFileCount());
+    assertTrue(2 < hdfsStore.getMaxInputFileCount());
     
     ArrayList<TrackedReference<TestHoplog>> targets = new ArrayList<TrackedReference<TestHoplog>>();
     for (int i = 0; i < 5; i++) {
@@ -417,8 +414,8 @@ public class TieredCompactionJUnitTest extends BaseHoplogTestCase {
     assertEquals(targets.size(), list.size());
     
     HDFSStoreMutator mutator = hdfsStore.createHdfsStoreMutator();
-    mutator.getCompactionConfigMutator().setMaxInputFileCount(2);
-    mutator.getCompactionConfigMutator().setMinInputFileCount(2);
+    mutator.setMaxInputFileCount(2);
+    mutator.setMinInputFileCount(2);
     hdfsStore.alter(mutator);
     
     compactor.getMinorCompactionTargets(list, -1);
@@ -458,7 +455,7 @@ public class TieredCompactionJUnitTest extends BaseHoplogTestCase {
     assertEquals(0, majorCReqCount.get());
     
     HDFSStoreMutator mutator = hdfsStore.createHdfsStoreMutator();
-    mutator.getCompactionConfigMutator().setMajorCompactionIntervalMins(1);
+    mutator.setMajorCompactionInterval(1);
     hdfsStore.alter(mutator);
     
     organizer.performMaintenance();

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/3772869d/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/hoplog/mapreduce/HoplogUtilJUnitTest.java
----------------------------------------------------------------------
diff --git a/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/hoplog/mapreduce/HoplogUtilJUnitTest.java b/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/hoplog/mapreduce/HoplogUtilJUnitTest.java
index 576144f..0cf5668 100644
--- a/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/hoplog/mapreduce/HoplogUtilJUnitTest.java
+++ b/gemfire-core/src/test/java/com/gemstone/gemfire/cache/hdfs/internal/hoplog/mapreduce/HoplogUtilJUnitTest.java
@@ -19,7 +19,6 @@ import org.apache.hadoop.fs.FileSystem;
 import org.apache.hadoop.fs.Path;
 import org.junit.experimental.categories.Category;
 
-import com.gemstone.gemfire.cache.hdfs.HDFSStoreFactory.HDFSCompactionConfigFactory;
 import com.gemstone.gemfire.cache.hdfs.internal.hoplog.AbstractHoplogOrganizer;
 import com.gemstone.gemfire.cache.hdfs.internal.hoplog.BaseHoplogTestCase;
 import com.gemstone.gemfire.cache.hdfs.internal.hoplog.HdfsSortedOplogOrganizer;
@@ -38,11 +37,9 @@ public class HoplogUtilJUnitTest extends BaseHoplogTestCase {
   protected void configureHdfsStoreFactory() throws Exception {
     super.configureHdfsStoreFactory();
     
-    HDFSCompactionConfigFactory factory = hsf.createCompactionConfigFactory(null);
-    factory.setMinInputFileCount(3);
+    hsf.setMinInputFileCount(3);
     hsf.setMinorCompaction(false);
-    factory.setAutoMajorCompaction(false);
-    hsf.setHDFSCompactionConfig(factory.create());
+    hsf.setMajorCompaction(false);
   }
   
   public void testHoplogListingMultiBucket() throws Exception {

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/3772869d/gemfire-core/src/test/java/com/gemstone/gemfire/internal/cache/HDFSRegionOperationsJUnitTest.java
----------------------------------------------------------------------
diff --git a/gemfire-core/src/test/java/com/gemstone/gemfire/internal/cache/HDFSRegionOperationsJUnitTest.java b/gemfire-core/src/test/java/com/gemstone/gemfire/internal/cache/HDFSRegionOperationsJUnitTest.java
index d068cb4..50b213a 100644
--- a/gemfire-core/src/test/java/com/gemstone/gemfire/internal/cache/HDFSRegionOperationsJUnitTest.java
+++ b/gemfire-core/src/test/java/com/gemstone/gemfire/internal/cache/HDFSRegionOperationsJUnitTest.java
@@ -36,7 +36,6 @@ import com.gemstone.gemfire.cache.RegionAttributes;
 import com.gemstone.gemfire.cache.RegionDestroyedException;
 import com.gemstone.gemfire.cache.RegionFactory;
 import com.gemstone.gemfire.cache.RegionShortcut;
-import com.gemstone.gemfire.cache.hdfs.HDFSEventQueueAttributesFactory;
 import com.gemstone.gemfire.cache.hdfs.HDFSStore;
 import com.gemstone.gemfire.cache.hdfs.HDFSStoreFactory;
 import com.gemstone.gemfire.cache.hdfs.internal.HDFSStoreFactoryImpl;
@@ -71,9 +70,7 @@ public class HDFSRegionOperationsJUnitTest extends TestCase {
     String storeName = getName()+"-store";
     HDFSStoreFactory hsf = cache.createHDFSStoreFactory();
     hsf.setHomeDir(getName()+"-test");
-    HDFSEventQueueAttributesFactory f = new HDFSEventQueueAttributesFactory();
-    f.setBatchTimeInterval(getBatchTimeInterval());
-    hsf.setHDFSEventQueueAttributes(f.create());
+    hsf.setBatchInterval(getBatchTimeInterval());
     hdfsStore = hsf.create(storeName);
   }
 

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/3772869d/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/commands/HDFSStoreCommandsJUnitTest.java
----------------------------------------------------------------------
diff --git a/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/commands/HDFSStoreCommandsJUnitTest.java b/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/commands/HDFSStoreCommandsJUnitTest.java
index b46abc7..52d7073 100644
--- a/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/commands/HDFSStoreCommandsJUnitTest.java
+++ b/gemfire-core/src/test/java/com/gemstone/gemfire/management/internal/cli/commands/HDFSStoreCommandsJUnitTest.java
@@ -38,9 +38,7 @@ import com.gemstone.gemfire.cache.execute.Execution;
 import com.gemstone.gemfire.cache.execute.FunctionInvocationTargetException;
 import com.gemstone.gemfire.cache.execute.ResultCollector;
 import com.gemstone.gemfire.cache.hdfs.HDFSStore;
-import com.gemstone.gemfire.cache.hdfs.internal.HDFSEventQueueAttributesImpl;
 import com.gemstone.gemfire.cache.hdfs.internal.HDFSStoreConfigHolder;
-import com.gemstone.gemfire.cache.hdfs.internal.HDFSStoreConfigHolder.AbstractHDFSCompactionConfigHolder;
 import com.gemstone.gemfire.distributed.DistributedMember;
 import com.gemstone.gemfire.internal.cache.execute.AbstractExecution;
 import com.gemstone.gemfire.management.cli.Result;
@@ -108,7 +106,7 @@ public class HDFSStoreCommandsJUnitTest {
     final Execution mockFunctionExecutor = mockContext.mock(Execution.class, "Function Executor");
     final ResultCollector mockResultCollector = mockContext.mock(ResultCollector.class, "ResultCollector");
 
-    final HDFSStoreConfigHolder expectedHdfsStoreConfigHolder = createMockHDFSStoreConfigHolder("hdfsStoreName",
+    final HDFSStoreConfigHolder expectedHdfsStoreConfigHolder = createMockHDFSStoreConfigHolder(mockContext, "hdfsStoreName",
         "hdfs://localhost:9000", "testDir", 1024, 20, .25f, null, 40, 40, null, false, 0, 2048, true, true, true, 40,
         40, 40, 800);
 
@@ -277,13 +275,13 @@ public class HDFSStoreCommandsJUnitTest {
 
     final ResultCollector mockResultCollector = mockContext.mock(ResultCollector.class, "ResultCollector");
 
-    final HDFSStoreConfigHolder expectedHdfsStoreConfigHolderOne = createMockHDFSStoreConfigHolder("hdfsStoreName1",
+    final HDFSStoreConfigHolder expectedHdfsStoreConfigHolderOne = createMockHDFSStoreConfigHolder(mockContext, "hdfsStoreName1",
         "hdfs://localhost:9000", "testDir", 1024, 20, .25f, null, 40, 40, null, false, 0, 2048, true, true, true, 40,
         40, 40, 800);
-    final HDFSStoreConfigHolder expectedHdfsStoreConfigHolderTwo = createMockHDFSStoreConfigHolder("hdfsStoreName2",
+    final HDFSStoreConfigHolder expectedHdfsStoreConfigHolderTwo = createMockHDFSStoreConfigHolder(mockContext, "hdfsStoreName2",
         "hdfs://localhost:9000", "testDir", 1024, 20, .25f, null, 40, 40, null, false, 0, 2048, true, true, true, 40,
         40, 40, 800);
-    final HDFSStoreConfigHolder expectedHdfsStoreConfigHolderThree = createMockHDFSStoreConfigHolder("hdfsStoreName3",
+    final HDFSStoreConfigHolder expectedHdfsStoreConfigHolderThree = createMockHDFSStoreConfigHolder(mockContext, "hdfsStoreName3",
         "hdfs://localhost:9000", "testDir", 1024, 20, .25f, null, 40, 40, null, false, 0, 2048, true, true, true, 40,
         40, 40, 800);
  
@@ -349,7 +347,7 @@ public class HDFSStoreCommandsJUnitTest {
     final AbstractExecution mockFunctionExecutor = mockContext.mock(AbstractExecution.class, "Function Executor");
     final ResultCollector mockResultCollector = mockContext.mock(ResultCollector.class, "ResultCollector");
 
-    final HDFSStoreConfigHolder expectedHdfsStoreConfigHolder = createMockHDFSStoreConfigHolder("hdfsStoreName",
+    final HDFSStoreConfigHolder expectedHdfsStoreConfigHolder = createMockHDFSStoreConfigHolder(mockContext, "hdfsStoreName",
         "hdfs://localhost:9000", "testDir", 1024, 20, .25f, null, 40, 40, null, false, 0, 2048, true, true, true, 40,
         40, 40, 800);
 
@@ -710,7 +708,7 @@ public class HDFSStoreCommandsJUnitTest {
     assertEquals("No matching hdfs stores found.", (((JSONArray)jsonObject.get("message")).get(0)));
   }
 
-  protected HDFSStoreConfigHolder createMockHDFSStoreConfigHolder(final String storeName, final String namenode,
+  public static HDFSStoreConfigHolder createMockHDFSStoreConfigHolder(Mockery mockContext, final String storeName, final String namenode,
       final String homeDir, final int maxFileSize, final int fileRolloverInterval, final float blockCachesize,
       final String clientConfigFile, final int batchSize, final int batchInterval, final String diskStoreName,
       final boolean syncDiskwrite, final int dispatcherThreads, final int maxMemory, final boolean bufferPersistent,
@@ -719,23 +717,22 @@ public class HDFSStoreCommandsJUnitTest {
 
     HDFSStoreConfigHolder mockHdfsStore = mockContext.mock(HDFSStoreConfigHolder.class, "HDFSStoreConfigHolder_"
         + storeName);
-    HDFSEventQueueAttributesImpl mockEventQueue = createMockEventQueue("hdfsStoreConfig_" + storeName, batchSize,
-        batchInterval, diskStoreName, syncDiskwrite, dispatcherThreads, maxMemory, bufferPersistent);
-
-    AbstractHDFSCompactionConfigHolder mockCompactionConfig = createMockHDFSCompactionConfigHolder("hdfsStoreConfig_"
-        + storeName, minorCompact, majorCompact, majorCompactionInterval, majorCompactionThreads,
-        minorCompactionThreads, purgeInterval);
 
-    mockHdfsStore = (HDFSStoreConfigHolder)createMockStore(mockHdfsStore, storeName, namenode, homeDir, maxFileSize,
-        fileRolloverInterval, minorCompact, blockCachesize, clientConfigFile, mockCompactionConfig, mockEventQueue);
+    createMockStore(mockContext, mockHdfsStore, storeName, namenode, homeDir, maxFileSize, fileRolloverInterval,
+        minorCompact, minorCompactionThreads, majorCompact, majorCompactionThreads, majorCompactionInterval,
+        purgeInterval, blockCachesize, clientConfigFile, batchSize,
+        batchInterval, diskStoreName, syncDiskwrite, dispatcherThreads, maxMemory, bufferPersistent);
     return mockHdfsStore;
 
   }
 
-  private HDFSStore createMockStore(final HDFSStore mockStore, final String storeName, final String namenode,
-      final String homeDir, final int maxFileSize, final int fileRolloverInterval, final boolean minorCompact, final float blockCachesize,
-      final String clientConfigFile, final AbstractHDFSCompactionConfigHolder mockCompactionConfig,
-      final HDFSEventQueueAttributesImpl mockEventQueue) {
+  public static void createMockStore(Mockery mockContext, final HDFSStore mockStore, final String storeName,
+      final String namenode, final String homeDir, final int maxFileSize, final int fileRolloverInterval,
+      final boolean minorCompact, final int minorCompactionThreads, final boolean majorCompact,
+      final int majorCompactionThreads, final int majorCompactionInterval, final int purgeInterval,
+      final float blockCachesize, final String clientConfigFile, final int batchSize, final int batchInterval,
+      final String diskStoreName, final boolean syncDiskwrite, final int dispatcherThreads, final int maxMemory,
+      final boolean bufferPersistent) {
 
     mockContext.checking(new Expectations() {
       {
@@ -745,86 +742,49 @@ public class HDFSStoreCommandsJUnitTest {
         will(returnValue(namenode));
         allowing(mockStore).getHomeDir();
         will(returnValue(homeDir));
-        allowing(mockStore).getMaxFileSize();
+        allowing(mockStore).getMaxWriteOnlyFileSize();
         will(returnValue(maxFileSize));
-        allowing(mockStore).getFileRolloverInterval();
+        allowing(mockStore).getWriteOnlyFileRolloverInterval();
         will(returnValue(fileRolloverInterval));
         allowing(mockStore).getMinorCompaction();
         will(returnValue(minorCompact));
+        allowing(mockStore).getMajorCompaction();
+        will(returnValue(majorCompact));
+        allowing(mockStore).getMajorCompactionInterval();
+        will(returnValue(majorCompactionInterval));
+        allowing(mockStore).getMajorCompactionThreads();
+        will(returnValue(majorCompactionThreads));
+        allowing(mockStore).getMinorCompactionThreads();
+        will(returnValue(minorCompactionThreads));
+        allowing(mockStore).getPurgeInterval();
+        will(returnValue(purgeInterval));
+        allowing(mockStore).getMaxInputFileCount();
+        will(returnValue(10));
+        allowing(mockStore).getMaxInputFileSizeMB();
+        will(returnValue(1024));
+        allowing(mockStore).getMinInputFileCount();
+        will(returnValue(2));
         allowing(mockStore).getBlockCacheSize();
         will(returnValue(blockCachesize));
         allowing(mockStore).getHDFSClientConfigFile();
         will(returnValue(clientConfigFile));
-        allowing(mockStore).getHDFSEventQueueAttributes();
-        will(returnValue(mockEventQueue));
-        allowing(mockStore).getHDFSCompactionConfig();
-        will(returnValue(mockCompactionConfig));
-      }
-    });
-    return mockStore;
-
-  }
 
-  private HDFSEventQueueAttributesImpl createMockEventQueue(final String name, final int batchSize,
-      final int batchInterval, final String diskStoreName, final boolean syncDiskwrite, final int dispatcherThreads,
-      final int maxMemory, final boolean bufferPersistent) {
-
-    final HDFSEventQueueAttributesImpl mockEventQueue = mockContext.mock(HDFSEventQueueAttributesImpl.class, name
-        + "EventQueueImpl");
-
-    mockContext.checking(new Expectations() {
-      {
-        allowing(mockEventQueue).getBatchSizeMB();
+        allowing(mockStore).getBatchSize();
         will(returnValue(batchSize));
-        allowing(mockEventQueue).getBatchTimeInterval();
+        allowing(mockStore).getBatchInterval();
         will(returnValue(batchInterval));
-        allowing(mockEventQueue).getDiskStoreName();
+        allowing(mockStore).getDiskStoreName();
         will(returnValue(diskStoreName));
-        allowing(mockEventQueue).isDiskSynchronous();
+        allowing(mockStore).getSynchronousDiskWrite();
         will(returnValue(syncDiskwrite));
-        allowing(mockEventQueue).isPersistent();
+        allowing(mockStore).getBufferPersistent();
         will(returnValue(bufferPersistent));
-        allowing(mockEventQueue).getDispatcherThreads();
+        allowing(mockStore).getDispatcherThreads();
         will(returnValue(dispatcherThreads));
-        allowing(mockEventQueue).getMaximumQueueMemory();
+        allowing(mockStore).getMaxMemory();
         will(returnValue(maxMemory));
       }
     });
-
-    return mockEventQueue;
-  }
-
-  private AbstractHDFSCompactionConfigHolder createMockHDFSCompactionConfigHolder(final String name,
-      final boolean minorCompact, final boolean majorCompact, final int majorCompactionInterval,
-      final int majorCompactionThreads, final int minorCompactionThreads, final int purgeInterval) {
-
-    final AbstractHDFSCompactionConfigHolder mockCompactionConfig = mockContext.mock(
-        AbstractHDFSCompactionConfigHolder.class, name + "CompactionConfig");
-
-    mockContext.checking(new Expectations() {
-      {
-        allowing(mockCompactionConfig).getAutoMajorCompaction();
-        will(returnValue(majorCompact));
-        allowing(mockCompactionConfig).getMajorCompactionIntervalMins();
-        will(returnValue(majorCompactionInterval));
-        allowing(mockCompactionConfig).getMajorCompactionMaxThreads();
-        will(returnValue(majorCompactionThreads));
-        allowing(mockCompactionConfig).getMaxThreads();
-        will(returnValue(minorCompactionThreads));
-        allowing(mockCompactionConfig).getOldFilesCleanupIntervalMins();
-        will(returnValue(purgeInterval));
-        allowing(mockCompactionConfig).getMaxInputFileCount();
-        will(returnValue(10));
-        allowing(mockCompactionConfig).getMaxInputFileSizeMB();
-        will(returnValue(1024));
-        allowing(mockCompactionConfig).getMinInputFileCount();
-        will(returnValue(2));
-        allowing(mockCompactionConfig).getCompactionStrategy();
-        will(returnValue(null));
-      }
-    });
-
-    return mockCompactionConfig;
   }
 
   protected static class TestHDFSStoreCommands extends HDFSStoreCommands {


Mime
View raw message