View Javadoc

1   /**
2    *
3    * Licensed to the Apache Software Foundation (ASF) under one
4    * or more contributor license agreements.  See the NOTICE file
5    * distributed with this work for additional information
6    * regarding copyright ownership.  The ASF licenses this file
7    * to you under the Apache License, Version 2.0 (the
8    * "License"); you may not use this file except in compliance
9    * with the License.  You may obtain a copy of the License at
10   *
11   *     http://www.apache.org/licenses/LICENSE-2.0
12   *
13   * Unless required by applicable law or agreed to in writing, software
14   * distributed under the License is distributed on an "AS IS" BASIS,
15   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16   * See the License for the specific language governing permissions and
17   * limitations under the License.
18   */
19  package org.apache.hadoop.hbase.regionserver;
20  
21  import static org.junit.Assert.assertEquals;
22  import static org.junit.Assert.assertFalse;
23  import static org.junit.Assert.assertTrue;
24  import static org.junit.Assert.fail;
25  
26  import java.lang.management.ManagementFactory;
27  import java.util.Iterator;
28  
29  import org.apache.hadoop.conf.Configuration;
30  import org.apache.hadoop.hbase.ChoreService;
31  import org.apache.hadoop.hbase.CoordinatedStateManager;
32  import org.apache.hadoop.hbase.HBaseConfiguration;
33  import org.apache.hadoop.hbase.HConstants;
34  import org.apache.hadoop.hbase.Server;
35  import org.apache.hadoop.hbase.ServerName;
36  import org.apache.hadoop.hbase.testclassification.SmallTests;
37  import org.apache.hadoop.hbase.client.ClusterConnection;
38  import org.apache.hadoop.hbase.io.hfile.BlockCache;
39  import org.apache.hadoop.hbase.io.hfile.BlockCacheKey;
40  import org.apache.hadoop.hbase.io.hfile.CacheStats;
41  import org.apache.hadoop.hbase.io.hfile.Cacheable;
42  import org.apache.hadoop.hbase.io.hfile.CachedBlock;
43  import org.apache.hadoop.hbase.io.hfile.ResizableBlockCache;
44  import org.apache.hadoop.hbase.io.util.HeapMemorySizeUtil;
45  import org.apache.hadoop.hbase.regionserver.HeapMemoryManager.TunerContext;
46  import org.apache.hadoop.hbase.regionserver.HeapMemoryManager.TunerResult;
47  import org.apache.hadoop.hbase.zookeeper.MetaTableLocator;
48  import org.apache.hadoop.hbase.zookeeper.ZooKeeperWatcher;
49  import org.junit.Test;
50  import org.junit.experimental.categories.Category;
51  
52  @Category(SmallTests.class)
53  public class TestHeapMemoryManager {
54  
55    private long maxHeapSize = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getMax();
56  
57    @Test
58    public void testAutoTunerShouldBeOffWhenMaxMinRangesForMemstoreIsNotGiven() throws Exception {
59      Configuration conf = HBaseConfiguration.create();
60      conf.setFloat(HeapMemorySizeUtil.MEMSTORE_SIZE_KEY, 0.02f);
61      conf.setFloat(HeapMemoryManager.BLOCK_CACHE_SIZE_MAX_RANGE_KEY, 0.75f);
62      conf.setFloat(HeapMemoryManager.BLOCK_CACHE_SIZE_MIN_RANGE_KEY, 0.03f);
63      HeapMemoryManager manager = new HeapMemoryManager(new BlockCacheStub(0),
64          new MemstoreFlusherStub(0), new RegionServerStub(conf));
65      assertFalse(manager.isTunerOn());
66    }
67  
68    @Test
69    public void testAutoTunerShouldBeOffWhenMaxMinRangesForBlockCacheIsNotGiven() throws Exception {
70      Configuration conf = HBaseConfiguration.create();
71      conf.setFloat(HConstants.HFILE_BLOCK_CACHE_SIZE_KEY, 0.02f);
72      conf.setFloat(HeapMemoryManager.MEMSTORE_SIZE_MAX_RANGE_KEY, 0.75f);
73      conf.setFloat(HeapMemoryManager.MEMSTORE_SIZE_MIN_RANGE_KEY, 0.03f);
74      HeapMemoryManager manager = new HeapMemoryManager(new BlockCacheStub(0),
75          new MemstoreFlusherStub(0), new RegionServerStub(conf));
76      assertFalse(manager.isTunerOn());
77    }
78  
79    @Test
80    public void testWhenMemstoreAndBlockCacheMaxMinChecksFails() throws Exception {
81      BlockCacheStub blockCache = new BlockCacheStub(0);
82      MemstoreFlusherStub memStoreFlusher = new MemstoreFlusherStub(0);
83      Configuration conf = HBaseConfiguration.create();
84      conf.setFloat(HeapMemoryManager.MEMSTORE_SIZE_MAX_RANGE_KEY, 0.75f);
85      conf.setFloat(HeapMemoryManager.BLOCK_CACHE_SIZE_MIN_RANGE_KEY, 0.06f);
86      try {
87        new HeapMemoryManager(blockCache, memStoreFlusher, new RegionServerStub(conf));
88        fail();
89      } catch (RuntimeException e) {
90      }
91      conf = HBaseConfiguration.create();
92      conf.setFloat(HeapMemoryManager.MEMSTORE_SIZE_MIN_RANGE_KEY, 0.2f);
93      conf.setFloat(HeapMemoryManager.BLOCK_CACHE_SIZE_MAX_RANGE_KEY, 0.7f);
94      try {
95        new HeapMemoryManager(blockCache, memStoreFlusher, new RegionServerStub(conf));
96        fail();
97      } catch (RuntimeException e) {
98      }
99    }
100 
101   @Test
102   public void testWhenClusterIsWriteHeavy() throws Exception {
103     BlockCacheStub blockCache = new BlockCacheStub((long) (maxHeapSize * 0.4));
104     MemstoreFlusherStub memStoreFlusher = new MemstoreFlusherStub((long) (maxHeapSize * 0.4));
105     Configuration conf = HBaseConfiguration.create();
106     conf.setFloat(HeapMemoryManager.MEMSTORE_SIZE_MAX_RANGE_KEY, 0.75f);
107     conf.setFloat(HeapMemoryManager.MEMSTORE_SIZE_MIN_RANGE_KEY, 0.10f);
108     conf.setFloat(HeapMemoryManager.BLOCK_CACHE_SIZE_MAX_RANGE_KEY, 0.7f);
109     conf.setFloat(HeapMemoryManager.BLOCK_CACHE_SIZE_MIN_RANGE_KEY, 0.05f);
110     conf.setLong(HeapMemoryManager.HBASE_RS_HEAP_MEMORY_TUNER_PERIOD, 1000);
111     // Let the system start with default values for memstore heap and block cache size.
112     HeapMemoryManager heapMemoryManager = new HeapMemoryManager(blockCache, memStoreFlusher,
113         new RegionServerStub(conf));
114     long oldMemstoreHeapSize = memStoreFlusher.memstoreSize;
115     long oldBlockCacheSize = blockCache.maxSize;
116     final ChoreService choreService = new ChoreService("TEST_SERVER_NAME");
117     heapMemoryManager.start(choreService);
118     memStoreFlusher.flushType = FlushType.ABOVE_HIGHER_MARK;
119     memStoreFlusher.requestFlush(null, false);
120     memStoreFlusher.requestFlush(null, false);
121     memStoreFlusher.requestFlush(null, false);
122     memStoreFlusher.flushType = FlushType.ABOVE_LOWER_MARK;
123     memStoreFlusher.requestFlush(null, false);
124     Thread.sleep(1500); // Allow the tuner to run once and do necessary memory up
125     assertHeapSpaceDelta(DefaultHeapMemoryTuner.DEFAULT_STEP_VALUE, oldMemstoreHeapSize,
126         memStoreFlusher.memstoreSize);
127     assertHeapSpaceDelta(-(DefaultHeapMemoryTuner.DEFAULT_STEP_VALUE), oldBlockCacheSize,
128         blockCache.maxSize);
129     oldMemstoreHeapSize = memStoreFlusher.memstoreSize;
130     oldBlockCacheSize = blockCache.maxSize;
131     // Do some more flushes before the next run of HeapMemoryTuner
132     memStoreFlusher.flushType = FlushType.ABOVE_HIGHER_MARK;
133     memStoreFlusher.requestFlush(null, false);
134     memStoreFlusher.requestFlush(null, false);
135     Thread.sleep(1500);
136     assertHeapSpaceDelta(DefaultHeapMemoryTuner.DEFAULT_STEP_VALUE, oldMemstoreHeapSize,
137         memStoreFlusher.memstoreSize);
138     assertHeapSpaceDelta(-(DefaultHeapMemoryTuner.DEFAULT_STEP_VALUE), oldBlockCacheSize,
139         blockCache.maxSize);
140   }
141 
142   @Test
143   public void testWhenClusterIsReadHeavy() throws Exception {
144     BlockCacheStub blockCache = new BlockCacheStub((long) (maxHeapSize * 0.4));
145     MemstoreFlusherStub memStoreFlusher = new MemstoreFlusherStub((long) (maxHeapSize * 0.4));
146     Configuration conf = HBaseConfiguration.create();
147     conf.setFloat(HeapMemoryManager.MEMSTORE_SIZE_MAX_RANGE_KEY, 0.75f);
148     conf.setFloat(HeapMemoryManager.MEMSTORE_SIZE_MIN_RANGE_KEY, 0.10f);
149     conf.setFloat(HeapMemoryManager.BLOCK_CACHE_SIZE_MAX_RANGE_KEY, 0.7f);
150     conf.setFloat(HeapMemoryManager.BLOCK_CACHE_SIZE_MIN_RANGE_KEY, 0.05f);
151     conf.setLong(HeapMemoryManager.HBASE_RS_HEAP_MEMORY_TUNER_PERIOD, 1000);
152     // Let the system start with default values for memstore heap and block cache size.
153     HeapMemoryManager heapMemoryManager = new HeapMemoryManager(blockCache, memStoreFlusher,
154         new RegionServerStub(conf));
155     long oldMemstoreHeapSize = memStoreFlusher.memstoreSize;
156     long oldBlockCacheSize = blockCache.maxSize;
157     final ChoreService choreService = new ChoreService("TEST_SERVER_NAME");
158     heapMemoryManager.start(choreService);
159     blockCache.evictBlock(null);
160     blockCache.evictBlock(null);
161     blockCache.evictBlock(null);
162     Thread.sleep(1500); // Allow the tuner to run once and do necessary memory up
163     assertHeapSpaceDelta(-(DefaultHeapMemoryTuner.DEFAULT_STEP_VALUE), oldMemstoreHeapSize,
164         memStoreFlusher.memstoreSize);
165     assertHeapSpaceDelta(DefaultHeapMemoryTuner.DEFAULT_STEP_VALUE, oldBlockCacheSize,
166         blockCache.maxSize);
167     oldMemstoreHeapSize = memStoreFlusher.memstoreSize;
168     oldBlockCacheSize = blockCache.maxSize;
169     // Do some more evictions before the next run of HeapMemoryTuner
170     blockCache.evictBlock(null);
171     Thread.sleep(1500);
172     assertHeapSpaceDelta(-(DefaultHeapMemoryTuner.DEFAULT_STEP_VALUE), oldMemstoreHeapSize,
173         memStoreFlusher.memstoreSize);
174     assertHeapSpaceDelta(DefaultHeapMemoryTuner.DEFAULT_STEP_VALUE, oldBlockCacheSize,
175         blockCache.maxSize);
176   }
177 
178   @Test
179   public void testPluggingInHeapMemoryTuner() throws Exception {
180     BlockCacheStub blockCache = new BlockCacheStub((long) (maxHeapSize * 0.4));
181     MemstoreFlusherStub memStoreFlusher = new MemstoreFlusherStub((long) (maxHeapSize * 0.4));
182     Configuration conf = HBaseConfiguration.create();
183     conf.setFloat(HeapMemoryManager.MEMSTORE_SIZE_MAX_RANGE_KEY, 0.78f);
184     conf.setFloat(HeapMemoryManager.MEMSTORE_SIZE_MIN_RANGE_KEY, 0.05f);
185     conf.setFloat(HeapMemoryManager.BLOCK_CACHE_SIZE_MAX_RANGE_KEY, 0.75f);
186     conf.setFloat(HeapMemoryManager.BLOCK_CACHE_SIZE_MIN_RANGE_KEY, 0.02f);
187     conf.setLong(HeapMemoryManager.HBASE_RS_HEAP_MEMORY_TUNER_PERIOD, 1000);
188     conf.setClass(HeapMemoryManager.HBASE_RS_HEAP_MEMORY_TUNER_CLASS, CustomHeapMemoryTuner.class,
189         HeapMemoryTuner.class);
190     // Let the system start with default values for memstore heap and block cache size.
191     HeapMemoryManager heapMemoryManager = new HeapMemoryManager(blockCache, memStoreFlusher,
192         new RegionServerStub(conf));
193     final ChoreService choreService = new ChoreService("TEST_SERVER_NAME");
194     heapMemoryManager.start(choreService);
195     // Now we wants to be in write mode. Set bigger memstore size from CustomHeapMemoryTuner
196     CustomHeapMemoryTuner.memstoreSize = 0.78f;
197     CustomHeapMemoryTuner.blockCacheSize = 0.02f;
198     Thread.sleep(1500); // Allow the tuner to run once and do necessary memory up
199     assertHeapSpace(0.78f, memStoreFlusher.memstoreSize);// Memstore
200     assertHeapSpace(0.02f, blockCache.maxSize);// BlockCache
201     // Now we wants to be in read mode. Set bigger memstore size from CustomHeapMemoryTuner
202     CustomHeapMemoryTuner.blockCacheSize = 0.75f;
203     CustomHeapMemoryTuner.memstoreSize = 0.05f;
204     Thread.sleep(1500); // Allow the tuner to run once and do necessary memory up
205     assertHeapSpace(0.75f, blockCache.maxSize);// BlockCache
206     assertHeapSpace(0.05f, memStoreFlusher.memstoreSize);// Memstore
207   }
208 
209   @Test
210   public void testWhenSizeGivenByHeapTunerGoesOutsideRange() throws Exception {
211     BlockCacheStub blockCache = new BlockCacheStub((long) (maxHeapSize * 0.4));
212     MemstoreFlusherStub memStoreFlusher = new MemstoreFlusherStub((long) (maxHeapSize * 0.4));
213     Configuration conf = HBaseConfiguration.create();
214     conf.setFloat(HeapMemoryManager.MEMSTORE_SIZE_MAX_RANGE_KEY, 0.7f);
215     conf.setFloat(HeapMemoryManager.MEMSTORE_SIZE_MIN_RANGE_KEY, 0.1f);
216     conf.setFloat(HeapMemoryManager.BLOCK_CACHE_SIZE_MAX_RANGE_KEY, 0.7f);
217     conf.setFloat(HeapMemoryManager.BLOCK_CACHE_SIZE_MIN_RANGE_KEY, 0.1f);
218     conf.setLong(HeapMemoryManager.HBASE_RS_HEAP_MEMORY_TUNER_PERIOD, 1000);
219     conf.setClass(HeapMemoryManager.HBASE_RS_HEAP_MEMORY_TUNER_CLASS, CustomHeapMemoryTuner.class,
220         HeapMemoryTuner.class);
221     HeapMemoryManager heapMemoryManager = new HeapMemoryManager(blockCache, memStoreFlusher,
222         new RegionServerStub(conf));
223     final ChoreService choreService = new ChoreService("TEST_SERVER_NAME");
224     heapMemoryManager.start(choreService);
225     CustomHeapMemoryTuner.memstoreSize = 0.78f;
226     CustomHeapMemoryTuner.blockCacheSize = 0.02f;
227     Thread.sleep(1500); // Allow the tuner to run once and do necessary memory up
228     // Even if the tuner says to set the memstore to 78%, HBase makes it as 70% as that is the
229     // upper bound. Same with block cache as 10% is the lower bound.
230     assertHeapSpace(0.7f, memStoreFlusher.memstoreSize);
231     assertHeapSpace(0.1f, blockCache.maxSize);
232   }
233 
234   @Test
235   public void testWhenCombinedHeapSizesFromTunerGoesOutSideMaxLimit() throws Exception {
236     BlockCacheStub blockCache = new BlockCacheStub((long) (maxHeapSize * 0.4));
237     MemstoreFlusherStub memStoreFlusher = new MemstoreFlusherStub((long) (maxHeapSize * 0.4));
238     Configuration conf = HBaseConfiguration.create();
239     conf.setFloat(HeapMemoryManager.MEMSTORE_SIZE_MAX_RANGE_KEY, 0.7f);
240     conf.setFloat(HeapMemoryManager.MEMSTORE_SIZE_MIN_RANGE_KEY, 0.1f);
241     conf.setFloat(HeapMemoryManager.BLOCK_CACHE_SIZE_MAX_RANGE_KEY, 0.7f);
242     conf.setFloat(HeapMemoryManager.BLOCK_CACHE_SIZE_MIN_RANGE_KEY, 0.1f);
243     conf.setLong(HeapMemoryManager.HBASE_RS_HEAP_MEMORY_TUNER_PERIOD, 1000);
244     conf.setClass(HeapMemoryManager.HBASE_RS_HEAP_MEMORY_TUNER_CLASS, CustomHeapMemoryTuner.class,
245         HeapMemoryTuner.class);
246     HeapMemoryManager heapMemoryManager = new HeapMemoryManager(blockCache, memStoreFlusher,
247         new RegionServerStub(conf));
248     long oldMemstoreSize = memStoreFlusher.memstoreSize;
249     long oldBlockCacheSize = blockCache.maxSize;
250     final ChoreService choreService = new ChoreService("TEST_SERVER_NAME");
251     heapMemoryManager.start(choreService);
252     CustomHeapMemoryTuner.memstoreSize = 0.7f;
253     CustomHeapMemoryTuner.blockCacheSize = 0.3f;
254     Thread.sleep(1500);
255     assertEquals(oldMemstoreSize, memStoreFlusher.memstoreSize);
256     assertEquals(oldBlockCacheSize, blockCache.maxSize);
257   }
258 
259   @Test
260   public void testWhenL2BlockCacheIsOnHeap() throws Exception {
261     HeapMemoryManager heapMemoryManager = null;
262     BlockCacheStub blockCache = new BlockCacheStub((long) (maxHeapSize * 0.4));
263     MemstoreFlusherStub memStoreFlusher = new MemstoreFlusherStub((long) (maxHeapSize * 0.3));
264     Configuration conf = HBaseConfiguration.create();
265     conf.setFloat(HeapMemoryManager.MEMSTORE_SIZE_MAX_RANGE_KEY, 0.7f);
266     conf.setFloat(HeapMemoryManager.MEMSTORE_SIZE_MIN_RANGE_KEY, 0.1f);
267     conf.setFloat(HeapMemoryManager.BLOCK_CACHE_SIZE_MAX_RANGE_KEY, 0.7f);
268     conf.setFloat(HeapMemoryManager.BLOCK_CACHE_SIZE_MIN_RANGE_KEY, 0.1f);
269 
270     conf.setFloat(HeapMemorySizeUtil.MEMSTORE_SIZE_KEY, 0.4F);
271     conf.setFloat(HConstants.HFILE_BLOCK_CACHE_SIZE_KEY, 0.3F);
272     conf.setFloat(HConstants.BUCKET_CACHE_SIZE_KEY, 0.1F);
273     conf.set(HConstants.BUCKET_CACHE_IOENGINE_KEY, "heap");
274 
275     conf.setLong(HeapMemoryManager.HBASE_RS_HEAP_MEMORY_TUNER_PERIOD, 1000);
276     conf.setClass(HeapMemoryManager.HBASE_RS_HEAP_MEMORY_TUNER_CLASS, CustomHeapMemoryTuner.class,
277         HeapMemoryTuner.class);
278 
279     try {
280       heapMemoryManager = new HeapMemoryManager(blockCache, memStoreFlusher, new RegionServerStub(
281           conf));
282       fail("Should have failed as the collective heap memory need is above 80%");
283     } catch (Exception e) {
284     }
285 
286     // Change the max/min ranges for memstore and bock cache so as to pass the criteria check
287     conf.setFloat(HeapMemoryManager.MEMSTORE_SIZE_MAX_RANGE_KEY, 0.6f);
288     conf.setFloat(HeapMemoryManager.BLOCK_CACHE_SIZE_MAX_RANGE_KEY, 0.6f);
289     heapMemoryManager = new HeapMemoryManager(blockCache, memStoreFlusher, new RegionServerStub(
290         conf));
291     long oldMemstoreSize = memStoreFlusher.memstoreSize;
292     long oldBlockCacheSize = blockCache.maxSize;
293     final ChoreService choreService = new ChoreService("TEST_SERVER_NAME");
294     heapMemoryManager.start(choreService);
295     CustomHeapMemoryTuner.memstoreSize = 0.4f;
296     CustomHeapMemoryTuner.blockCacheSize = 0.4f;
297     Thread.sleep(1500);
298     // The size should not get changes as the collection of memstore size and L1 and L2 block cache
299     // size will cross the ax allowed 80% mark
300     assertEquals(oldMemstoreSize, memStoreFlusher.memstoreSize);
301     assertEquals(oldBlockCacheSize, blockCache.maxSize);
302     CustomHeapMemoryTuner.memstoreSize = 0.1f;
303     CustomHeapMemoryTuner.blockCacheSize = 0.5f;
304     Thread.sleep(1500);
305     assertHeapSpace(0.1f, memStoreFlusher.memstoreSize);
306     assertHeapSpace(0.5f, blockCache.maxSize);
307   }
308 
309   private void assertHeapSpace(float expectedHeapPercentage, long currentHeapSpace) {
310     long expected = (long) (this.maxHeapSize * expectedHeapPercentage);
311     assertEquals(expected, currentHeapSpace);
312   }
313 
314   private void assertHeapSpaceDelta(float expectedDeltaPercent, long oldHeapSpace, long newHeapSpace) {
315     long expctedMinDelta = (long) (this.maxHeapSize * expectedDeltaPercent);
316     if (expectedDeltaPercent > 0) {
317       assertTrue(expctedMinDelta <= (newHeapSpace - oldHeapSpace));
318     } else {
319       assertTrue(expctedMinDelta <= (oldHeapSpace - newHeapSpace));
320     }
321   }
322 
323   private static class BlockCacheStub implements ResizableBlockCache {
324     CacheStats stats = new CacheStats("test");
325     long maxSize = 0;
326 
327     public BlockCacheStub(long size){
328       this.maxSize = size;
329     }
330 
331     @Override
332     public void cacheBlock(BlockCacheKey cacheKey, Cacheable buf, boolean inMemory,
333         boolean cacheDataInL1) {
334 
335     }
336 
337     @Override
338     public void cacheBlock(BlockCacheKey cacheKey, Cacheable buf) {
339 
340     }
341 
342     @Override
343     public Cacheable getBlock(BlockCacheKey cacheKey, boolean caching, boolean repeat,
344         boolean updateCacheMetrics) {
345       return null;
346     }
347 
348     @Override
349     public boolean evictBlock(BlockCacheKey cacheKey) {
350       stats.evicted(0, cacheKey != null ? cacheKey.isPrimary() : true);
351       return false;
352     }
353 
354     @Override
355     public int evictBlocksByHfileName(String hfileName) {
356       stats.evicted(0, true); // Just assuming only one block for file here.
357       return 0;
358     }
359 
360     @Override
361     public CacheStats getStats() {
362       return this.stats;
363     }
364 
365     @Override
366     public void shutdown() {
367 
368     }
369 
370     @Override
371     public long size() {
372       return 0;
373     }
374 
375     @Override
376     public long getFreeSize() {
377       return 0;
378     }
379 
380     @Override
381     public long getCurrentSize() {
382       return 0;
383     }
384 
385     @Override
386     public long getBlockCount() {
387       return 0;
388     }
389 
390     @Override
391     public void setMaxSize(long size) {
392       this.maxSize = size;
393     }
394 
395     @Override
396     public Iterator<CachedBlock> iterator() {
397       return null;
398     }
399 
400     @Override
401     public BlockCache[] getBlockCaches() {
402       return null;
403     }
404   }
405 
406   private static class MemstoreFlusherStub implements FlushRequester {
407 
408     long memstoreSize;
409 
410     FlushRequestListener listener;
411 
412     FlushType flushType = FlushType.NORMAL;
413 
414     public MemstoreFlusherStub(long memstoreSize) {
415       this.memstoreSize = memstoreSize;
416     }
417 
418     @Override
419     public void requestFlush(Region region, boolean forceFlushAllStores) {
420       this.listener.flushRequested(flushType, region);
421     }
422 
423     @Override
424     public void requestDelayedFlush(Region region, long delay, boolean forceFlushAllStores) {
425 
426     }
427 
428     @Override
429     public void registerFlushRequestListener(FlushRequestListener listener) {
430       this.listener = listener;
431     }
432 
433     @Override
434     public boolean unregisterFlushRequestListener(FlushRequestListener listener) {
435       return false;
436     }
437 
438     @Override
439     public void setGlobalMemstoreLimit(long globalMemStoreSize) {
440       this.memstoreSize = globalMemStoreSize;
441     }
442   }
443 
444   private static class RegionServerStub implements Server {
445     private Configuration conf;
446     private boolean stopped = false;
447 
448     public RegionServerStub(Configuration conf) {
449       this.conf = conf;
450     }
451 
452     @Override
453     public void abort(String why, Throwable e) {
454 
455     }
456 
457     @Override
458     public boolean isAborted() {
459       return false;
460     }
461 
462     @Override
463     public void stop(String why) {
464       this.stopped = true;
465     }
466 
467     @Override
468     public boolean isStopped() {
469       return this.stopped;
470     }
471 
472     @Override
473     public Configuration getConfiguration() {
474       return this.conf;
475     }
476 
477     @Override
478     public ZooKeeperWatcher getZooKeeper() {
479       return null;
480     }
481 
482     @Override
483     public CoordinatedStateManager getCoordinatedStateManager() {
484       return null;
485     }
486 
487     @Override
488     public ClusterConnection getConnection() {
489       return null;
490     }
491 
492     @Override
493     public MetaTableLocator getMetaTableLocator() {
494       return null;
495     }
496 
497     @Override
498     public ServerName getServerName() {
499       return ServerName.valueOf("server1",4000,12345);
500     }
501 
502     @Override
503     public ChoreService getChoreService() {
504       return null;
505     }
506   }
507 
508   static class CustomHeapMemoryTuner implements HeapMemoryTuner {
509     static float blockCacheSize = 0.4f;
510     static float memstoreSize = 0.4f;
511 
512     @Override
513     public Configuration getConf() {
514       return null;
515     }
516 
517     @Override
518     public void setConf(Configuration arg0) {
519 
520     }
521 
522     @Override
523     public TunerResult tune(TunerContext context) {
524       TunerResult result = new TunerResult(true);
525       result.setBlockCacheSize(blockCacheSize);
526       result.setMemstoreSize(memstoreSize);
527       return result;
528     }
529   }
530 }