001/*
002 * Licensed to the Apache Software Foundation (ASF) under one
003 * or more contributor license agreements.  See the NOTICE file
004 * distributed with this work for additional information
005 * regarding copyright ownership.  The ASF licenses this file
006 * to you under the Apache License, Version 2.0 (the
007 * "License"); you may not use this file except in compliance
008 * with the License.  You may obtain a copy of the License at
009 *
010 *     http://www.apache.org/licenses/LICENSE-2.0
011 *
012 * Unless required by applicable law or agreed to in writing, software
013 * distributed under the License is distributed on an "AS IS" BASIS,
014 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
015 * See the License for the specific language governing permissions and
016 * limitations under the License.
017 */
018package org.apache.hadoop.hbase.hbtop;
019
020import static org.hamcrest.CoreMatchers.is;
021import static org.hamcrest.MatcherAssert.assertThat;
022import static org.junit.jupiter.api.Assertions.fail;
023
024import java.text.ParseException;
025import java.util.ArrayList;
026import java.util.Collections;
027import java.util.HashMap;
028import java.util.List;
029import java.util.Map;
030import org.apache.commons.lang3.time.FastDateFormat;
031import org.apache.hadoop.hbase.ClusterMetrics;
032import org.apache.hadoop.hbase.ClusterMetricsBuilder;
033import org.apache.hadoop.hbase.RegionMetrics;
034import org.apache.hadoop.hbase.RegionMetricsBuilder;
035import org.apache.hadoop.hbase.ServerMetrics;
036import org.apache.hadoop.hbase.ServerMetricsBuilder;
037import org.apache.hadoop.hbase.ServerName;
038import org.apache.hadoop.hbase.Size;
039import org.apache.hadoop.hbase.TableName;
040import org.apache.hadoop.hbase.UserMetrics;
041import org.apache.hadoop.hbase.UserMetricsBuilder;
042import org.apache.hadoop.hbase.client.RegionInfoBuilder;
043import org.apache.hadoop.hbase.hbtop.field.Field;
044import org.apache.hadoop.hbase.hbtop.screen.top.Summary;
045import org.apache.hadoop.hbase.master.RegionState;
046import org.apache.hadoop.hbase.util.Bytes;
047
048public final class TestUtils {
049
050  private TestUtils() {
051  }
052
053  private static final String TEST_USER_FOO = "FOO";
054  private static final String TEST_USER_BAR = "BAR";
055  private static final String TEST_HOST_ADDRESS_A = "10.0.0.1";
056  private static final String TEST_HOST_ADDRESS_B = "10.0.0.2";
057  private static final String TEST_SERVICE_NAME = "ClientService";
058  private static final String TEST_CLIENT_VERSION = "test-client-version";
059
060  public static ClusterMetrics createDummyClusterMetrics() {
061    Map<ServerName, ServerMetrics> serverMetricsMap = new HashMap<>();
062
063    // host1
064    List<RegionMetrics> regionMetricsList = new ArrayList<>();
065    List<UserMetrics> userMetricsList = new ArrayList<>();
066    userMetricsList.add(createUserMetrics(TEST_USER_FOO, 1, 2, 4, TEST_HOST_ADDRESS_A,
067      TEST_HOST_ADDRESS_B, TEST_CLIENT_VERSION, TEST_SERVICE_NAME));
068    userMetricsList.add(createUserMetrics(TEST_USER_BAR, 2, 3, 3, TEST_HOST_ADDRESS_A,
069      TEST_HOST_ADDRESS_B, TEST_CLIENT_VERSION, TEST_SERVICE_NAME));
070    regionMetricsList.add(createRegionMetrics("table1,,1.00000000000000000000000000000000.", 100,
071      50, 100, new Size(100, Size.Unit.MEGABYTE), new Size(200, Size.Unit.MEGABYTE), 1,
072      new Size(100, Size.Unit.MEGABYTE), 0.1f, 100, 100, "2019-07-22 00:00:00"));
073    regionMetricsList.add(createRegionMetrics("table2,1,2.00000000000000000000000000000001.", 200,
074      100, 200, new Size(200, Size.Unit.MEGABYTE), new Size(400, Size.Unit.MEGABYTE), 2,
075      new Size(200, Size.Unit.MEGABYTE), 0.2f, 50, 200, "2019-07-22 00:00:01"));
076    regionMetricsList
077      .add(createRegionMetrics("namespace:table3,,3_0001.00000000000000000000000000000002.", 300,
078        150, 300, new Size(300, Size.Unit.MEGABYTE), new Size(600, Size.Unit.MEGABYTE), 3,
079        new Size(300, Size.Unit.MEGABYTE), 0.3f, 100, 300, "2019-07-22 00:00:02"));
080
081    ServerName host1 = ServerName.valueOf("host1.apache.com", 1000, 1);
082    serverMetricsMap.put(host1, createServerMetrics(host1, 100, new Size(100, Size.Unit.MEGABYTE),
083      new Size(200, Size.Unit.MEGABYTE), 100, regionMetricsList, userMetricsList));
084
085    // host2
086    regionMetricsList.clear();
087    userMetricsList.clear();
088    userMetricsList.add(createUserMetrics(TEST_USER_FOO, 5, 7, 3, TEST_HOST_ADDRESS_A,
089      TEST_HOST_ADDRESS_B, TEST_CLIENT_VERSION, TEST_SERVICE_NAME));
090    userMetricsList.add(createUserMetrics(TEST_USER_BAR, 4, 8, 4, TEST_HOST_ADDRESS_A,
091      TEST_HOST_ADDRESS_B, TEST_CLIENT_VERSION, TEST_SERVICE_NAME));
092    regionMetricsList.add(createRegionMetrics("table1,1,4.00000000000000000000000000000003.", 100,
093      50, 100, new Size(100, Size.Unit.MEGABYTE), new Size(200, Size.Unit.MEGABYTE), 1,
094      new Size(100, Size.Unit.MEGABYTE), 0.4f, 50, 100, "2019-07-22 00:00:03"));
095    regionMetricsList.add(createRegionMetrics("table2,,5.00000000000000000000000000000004.", 200,
096      100, 200, new Size(200, Size.Unit.MEGABYTE), new Size(400, Size.Unit.MEGABYTE), 2,
097      new Size(200, Size.Unit.MEGABYTE), 0.5f, 150, 200, "2019-07-22 00:00:04"));
098    regionMetricsList
099      .add(createRegionMetrics("namespace:table3,,6.00000000000000000000000000000005.", 300, 150,
100        300, new Size(300, Size.Unit.MEGABYTE), new Size(600, Size.Unit.MEGABYTE), 3,
101        new Size(300, Size.Unit.MEGABYTE), 0.6f, 200, 300, "2019-07-22 00:00:05"));
102
103    ServerName host2 = ServerName.valueOf("host2.apache.com", 1001, 2);
104    serverMetricsMap.put(host2, createServerMetrics(host2, 200, new Size(16, Size.Unit.GIGABYTE),
105      new Size(32, Size.Unit.GIGABYTE), 200, regionMetricsList, userMetricsList));
106
107    ServerName host3 = ServerName.valueOf("host3.apache.com", 1002, 3);
108    return ClusterMetricsBuilder.newBuilder().setHBaseVersion("3.0.0-SNAPSHOT")
109      .setClusterId("01234567-89ab-cdef-0123-456789abcdef").setLiveServerMetrics(serverMetricsMap)
110      .setDeadServerNames(Collections.singletonList(host3))
111      .setRegionsInTransition(Collections
112        .singletonList(new RegionState(RegionInfoBuilder.newBuilder(TableName.valueOf("table4"))
113          .setStartKey(new byte[0]).setEndKey(new byte[0]).setOffline(true).setReplicaId(0)
114          .setRegionId(0).setSplit(false).build(), RegionState.State.OFFLINE, host3)))
115      .build();
116  }
117
118  private static UserMetrics createUserMetrics(String user, long readRequestCount,
119    long writeRequestCount, long filteredReadRequestsCount, String hostAddressA,
120    String hostAddressB, String clientVersion, String serviceName) {
121    return UserMetricsBuilder.newBuilder(Bytes.toBytes(user))
122      .addClientMetris(new UserMetricsBuilder.ClientMetricsImpl("CLIENT_A_" + user,
123        readRequestCount, writeRequestCount, filteredReadRequestsCount, hostAddressA, user,
124        serviceName, clientVersion))
125      .addClientMetris(new UserMetricsBuilder.ClientMetricsImpl("CLIENT_B_" + user,
126        readRequestCount, writeRequestCount, filteredReadRequestsCount, hostAddressB, user,
127        serviceName, clientVersion))
128      .build();
129  }
130
131  @SuppressWarnings("JavaUtilDate")
132  private static RegionMetrics createRegionMetrics(String regionName, long readRequestCount,
133    long filteredReadRequestCount, long writeRequestCount, Size storeFileSize,
134    Size uncompressedStoreFileSize, int storeFileCount, Size memStoreSize, float locality,
135    long compactedCellCount, long compactingCellCount, String lastMajorCompactionTime) {
136
137    FastDateFormat df = FastDateFormat.getInstance("yyyy-MM-dd HH:mm:ss");
138    try {
139      return RegionMetricsBuilder.newBuilder(Bytes.toBytes(regionName))
140        .setReadRequestCount(readRequestCount).setFilteredReadRequestCount(filteredReadRequestCount)
141        .setWriteRequestCount(writeRequestCount).setStoreFileSize(storeFileSize)
142        .setUncompressedStoreFileSize(uncompressedStoreFileSize).setStoreFileCount(storeFileCount)
143        .setMemStoreSize(memStoreSize).setDataLocality(locality)
144        .setCompactedCellCount(compactedCellCount).setCompactingCellCount(compactingCellCount)
145        .setLastMajorCompactionTimestamp(df.parse(lastMajorCompactionTime).getTime()).build();
146    } catch (ParseException e) {
147      throw new IllegalArgumentException(e);
148    }
149  }
150
151  private static ServerMetrics createServerMetrics(ServerName serverName, long reportTimestamp,
152    Size usedHeapSize, Size maxHeapSize, long requestCountPerSecond,
153    List<RegionMetrics> regionMetricsList, List<UserMetrics> userMetricsList) {
154
155    return ServerMetricsBuilder.newBuilder(serverName).setReportTimestamp(reportTimestamp)
156      .setUsedHeapSize(usedHeapSize).setMaxHeapSize(maxHeapSize)
157      .setRequestCountPerSecond(requestCountPerSecond).setRegionMetrics(regionMetricsList)
158      .setUserMetrics(userMetricsList).build();
159  }
160
161  public static void assertRecordsInRegionMode(List<Record> records) {
162    assertThat(records.size(), is(6));
163
164    for (Record record : records) {
165      switch (record.get(Field.REGION_NAME).asString()) {
166        case "table1,,1.00000000000000000000000000000000.":
167          assertRecordInRegionMode(record, "default", "1", "0", "table1",
168            "00000000000000000000000000000000", "host1:1000", "host1.apache.com,1000,1", 0L, 0L, 0L,
169            0L, new Size(100, Size.Unit.MEGABYTE), new Size(200, Size.Unit.MEGABYTE), 1,
170            new Size(100, Size.Unit.MEGABYTE), 0.1f, "", 100L, 100L, 100f, "2019-07-22 00:00:00");
171          break;
172
173        case "table1,1,4.00000000000000000000000000000003.":
174          assertRecordInRegionMode(record, "default", "4", "0", "table1",
175            "00000000000000000000000000000003", "host2:1001", "host2.apache.com,1001,2", 0L, 0L, 0L,
176            0L, new Size(100, Size.Unit.MEGABYTE), new Size(200, Size.Unit.MEGABYTE), 1,
177            new Size(100, Size.Unit.MEGABYTE), 0.4f, "1", 100L, 50L, 50f, "2019-07-22 00:00:03");
178          break;
179
180        case "table2,,5.00000000000000000000000000000004.":
181          assertRecordInRegionMode(record, "default", "5", "0", "table2",
182            "00000000000000000000000000000004", "host2:1001", "host2.apache.com,1001,2", 0L, 0L, 0L,
183            0L, new Size(200, Size.Unit.MEGABYTE), new Size(400, Size.Unit.MEGABYTE), 2,
184            new Size(200, Size.Unit.MEGABYTE), 0.5f, "", 200L, 150L, 75f, "2019-07-22 00:00:04");
185          break;
186
187        case "table2,1,2.00000000000000000000000000000001.":
188          assertRecordInRegionMode(record, "default", "2", "0", "table2",
189            "00000000000000000000000000000001", "host1:1000", "host1.apache.com,1000,1", 0L, 0L, 0L,
190            0L, new Size(200, Size.Unit.MEGABYTE), new Size(400, Size.Unit.MEGABYTE), 2,
191            new Size(200, Size.Unit.MEGABYTE), 0.2f, "1", 200L, 50L, 25f, "2019-07-22 00:00:01");
192          break;
193
194        case "namespace:table3,,6.00000000000000000000000000000005.":
195          assertRecordInRegionMode(record, "namespace", "6", "0", "table3",
196            "00000000000000000000000000000005", "host2:1001", "host2.apache.com,1001,2", 0L, 0L, 0L,
197            0L, new Size(300, Size.Unit.MEGABYTE), new Size(600, Size.Unit.MEGABYTE), 3,
198            new Size(300, Size.Unit.MEGABYTE), 0.6f, "", 300L, 200L, 66.66667f,
199            "2019-07-22 00:00:05");
200          break;
201
202        case "namespace:table3,,3_0001.00000000000000000000000000000002.":
203          assertRecordInRegionMode(record, "namespace", "3", "1", "table3",
204            "00000000000000000000000000000002", "host1:1000", "host1.apache.com,1000,1", 0L, 0L, 0L,
205            0L, new Size(300, Size.Unit.MEGABYTE), new Size(600, Size.Unit.MEGABYTE), 3,
206            new Size(300, Size.Unit.MEGABYTE), 0.3f, "", 300L, 100L, 33.333336f,
207            "2019-07-22 00:00:02");
208          break;
209
210        default:
211          fail();
212      }
213    }
214  }
215
216  private static void assertRecordInRegionMode(Record record, String namespace, String startCode,
217    String replicaId, String table, String region, String regionServer, String longRegionServer,
218    long requestCountPerSecond, long readRequestCountPerSecond,
219    long filteredReadRequestCountPerSecond, long writeCountRequestPerSecond, Size storeFileSize,
220    Size uncompressedStoreFileSize, int numStoreFiles, Size memStoreSize, float locality,
221    String startKey, long compactingCellCount, long compactedCellCount, float compactionProgress,
222    String lastMajorCompactionTime) {
223    assertThat(record.size(), is(22));
224    assertThat(record.get(Field.NAMESPACE).asString(), is(namespace));
225    assertThat(record.get(Field.START_CODE).asString(), is(startCode));
226    assertThat(record.get(Field.REPLICA_ID).asString(), is(replicaId));
227    assertThat(record.get(Field.TABLE).asString(), is(table));
228    assertThat(record.get(Field.REGION).asString(), is(region));
229    assertThat(record.get(Field.REGION_SERVER).asString(), is(regionServer));
230    assertThat(record.get(Field.LONG_REGION_SERVER).asString(), is(longRegionServer));
231    assertThat(record.get(Field.REQUEST_COUNT_PER_SECOND).asLong(), is(requestCountPerSecond));
232    assertThat(record.get(Field.READ_REQUEST_COUNT_PER_SECOND).asLong(),
233      is(readRequestCountPerSecond));
234    assertThat(record.get(Field.FILTERED_READ_REQUEST_COUNT_PER_SECOND).asLong(),
235      is(filteredReadRequestCountPerSecond));
236    assertThat(record.get(Field.WRITE_REQUEST_COUNT_PER_SECOND).asLong(),
237      is(writeCountRequestPerSecond));
238    assertThat(record.get(Field.STORE_FILE_SIZE).asSize(), is(storeFileSize));
239    assertThat(record.get(Field.UNCOMPRESSED_STORE_FILE_SIZE).asSize(),
240      is(uncompressedStoreFileSize));
241    assertThat(record.get(Field.NUM_STORE_FILES).asInt(), is(numStoreFiles));
242    assertThat(record.get(Field.MEM_STORE_SIZE).asSize(), is(memStoreSize));
243    assertThat(record.get(Field.LOCALITY).asFloat(), is(locality));
244    assertThat(record.get(Field.START_KEY).asString(), is(startKey));
245    assertThat(record.get(Field.COMPACTING_CELL_COUNT).asLong(), is(compactingCellCount));
246    assertThat(record.get(Field.COMPACTED_CELL_COUNT).asLong(), is(compactedCellCount));
247    assertThat(record.get(Field.COMPACTION_PROGRESS).asFloat(), is(compactionProgress));
248    assertThat(record.get(Field.LAST_MAJOR_COMPACTION_TIME).asString(),
249      is(lastMajorCompactionTime));
250  }
251
252  public static void assertRecordsInNamespaceMode(List<Record> records) {
253    assertThat(records.size(), is(2));
254
255    for (Record record : records) {
256      switch (record.get(Field.NAMESPACE).asString()) {
257        case "default":
258          assertRecordInNamespaceMode(record, 0L, 0L, 0L, 0L, new Size(600, Size.Unit.MEGABYTE),
259            new Size(1200, Size.Unit.MEGABYTE), 6, new Size(600, Size.Unit.MEGABYTE), 4);
260          break;
261
262        case "namespace":
263          assertRecordInNamespaceMode(record, 0L, 0L, 0L, 0L, new Size(600, Size.Unit.MEGABYTE),
264            new Size(1200, Size.Unit.MEGABYTE), 6, new Size(600, Size.Unit.MEGABYTE), 2);
265          break;
266
267        default:
268          fail();
269      }
270    }
271  }
272
273  private static void assertRecordInNamespaceMode(Record record, long requestCountPerSecond,
274    long readRequestCountPerSecond, long filteredReadRequestCountPerSecond,
275    long writeCountRequestPerSecond, Size storeFileSize, Size uncompressedStoreFileSize,
276    int numStoreFiles, Size memStoreSize, int regionCount) {
277    assertThat(record.size(), is(10));
278    assertThat(record.get(Field.REQUEST_COUNT_PER_SECOND).asLong(), is(requestCountPerSecond));
279    assertThat(record.get(Field.READ_REQUEST_COUNT_PER_SECOND).asLong(),
280      is(readRequestCountPerSecond));
281    assertThat(record.get(Field.FILTERED_READ_REQUEST_COUNT_PER_SECOND).asLong(),
282      is(filteredReadRequestCountPerSecond));
283    assertThat(record.get(Field.WRITE_REQUEST_COUNT_PER_SECOND).asLong(),
284      is(writeCountRequestPerSecond));
285    assertThat(record.get(Field.STORE_FILE_SIZE).asSize(), is(storeFileSize));
286    assertThat(record.get(Field.UNCOMPRESSED_STORE_FILE_SIZE).asSize(),
287      is(uncompressedStoreFileSize));
288    assertThat(record.get(Field.NUM_STORE_FILES).asInt(), is(numStoreFiles));
289    assertThat(record.get(Field.MEM_STORE_SIZE).asSize(), is(memStoreSize));
290    assertThat(record.get(Field.REGION_COUNT).asInt(), is(regionCount));
291  }
292
293  public static void assertRecordsInTableMode(List<Record> records) {
294    assertThat(records.size(), is(3));
295
296    for (Record record : records) {
297      String tableName = String.format("%s:%s", record.get(Field.NAMESPACE).asString(),
298        record.get(Field.TABLE).asString());
299
300      switch (tableName) {
301        case "default:table1":
302          assertRecordInTableMode(record, 0L, 0L, 0L, 0L, new Size(200, Size.Unit.MEGABYTE),
303            new Size(400, Size.Unit.MEGABYTE), 2, new Size(200, Size.Unit.MEGABYTE), 2);
304          break;
305
306        case "default:table2":
307          assertRecordInTableMode(record, 0L, 0L, 0L, 0L, new Size(400, Size.Unit.MEGABYTE),
308            new Size(800, Size.Unit.MEGABYTE), 4, new Size(400, Size.Unit.MEGABYTE), 2);
309          break;
310
311        case "namespace:table3":
312          assertRecordInTableMode(record, 0L, 0L, 0L, 0L, new Size(600, Size.Unit.MEGABYTE),
313            new Size(1200, Size.Unit.MEGABYTE), 6, new Size(600, Size.Unit.MEGABYTE), 2);
314          break;
315
316        default:
317          fail();
318      }
319    }
320  }
321
322  public static void assertRecordsInUserMode(List<Record> records) {
323    assertThat(records.size(), is(2));
324    for (Record record : records) {
325      String user = record.get(Field.USER).asString();
326      switch (user) {
327        // readRequestPerSecond and writeRequestPerSecond will be zero
328        // because there is no change or new metrics during refresh
329        case TEST_USER_FOO:
330          assertRecordInUserMode(record, 0L, 0L, 0L);
331          break;
332        case TEST_USER_BAR:
333          assertRecordInUserMode(record, 0L, 0L, 0L);
334          break;
335        default:
336          fail();
337      }
338    }
339  }
340
341  public static void assertRecordsInClientMode(List<Record> records) {
342    assertThat(records.size(), is(4));
343    for (Record record : records) {
344      String client = record.get(Field.CLIENT).asString();
345      switch (client) {
346        // readRequestPerSecond and writeRequestPerSecond will be zero
347        // because there is no change or new metrics during refresh
348        case "CLIENT_A_" + TEST_USER_FOO:
349          assertRecordInClientMode(record, 0L, 0L, 0L, TEST_HOST_ADDRESS_A, TEST_USER_FOO,
350            TEST_CLIENT_VERSION, TEST_SERVICE_NAME);
351          break;
352        case "CLIENT_A_" + TEST_USER_BAR:
353          assertRecordInClientMode(record, 0L, 0L, 0L, TEST_HOST_ADDRESS_A, TEST_USER_BAR,
354            TEST_CLIENT_VERSION, TEST_SERVICE_NAME);
355          break;
356        case "CLIENT_B_" + TEST_USER_FOO:
357          assertRecordInClientMode(record, 0L, 0L, 0L, TEST_HOST_ADDRESS_B, TEST_USER_FOO,
358            TEST_CLIENT_VERSION, TEST_SERVICE_NAME);
359          break;
360        case "CLIENT_B_" + TEST_USER_BAR:
361          assertRecordInClientMode(record, 0L, 0L, 0L, TEST_HOST_ADDRESS_B, TEST_USER_BAR,
362            TEST_CLIENT_VERSION, TEST_SERVICE_NAME);
363          break;
364        default:
365          fail();
366      }
367    }
368  }
369
370  private static void assertRecordInUserMode(Record record, long readRequestCountPerSecond,
371    long writeCountRequestPerSecond, long filteredReadRequestsCount) {
372    assertThat(record.size(), is(10));
373    assertThat(record.get(Field.READ_REQUEST_COUNT_PER_SECOND).asLong(),
374      is(readRequestCountPerSecond));
375    assertThat(record.get(Field.WRITE_REQUEST_COUNT_PER_SECOND).asLong(),
376      is(writeCountRequestPerSecond));
377    assertThat(record.get(Field.FILTERED_READ_REQUEST_COUNT_PER_SECOND).asLong(),
378      is(filteredReadRequestsCount));
379    assertThat(record.get(Field.CLIENT_COUNT).asInt(), is(2));
380  }
381
382  private static void assertRecordInClientMode(Record record, long readRequestCountPerSecond,
383    long writeCountRequestPerSecond, long filteredReadRequestsCount, String hostAddress,
384    String userName, String clientVersion, String serviceName) {
385    assertThat(record.size(), is(10));
386    assertThat(record.get(Field.READ_REQUEST_COUNT_PER_SECOND).asLong(),
387      is(readRequestCountPerSecond));
388    assertThat(record.get(Field.WRITE_REQUEST_COUNT_PER_SECOND).asLong(),
389      is(writeCountRequestPerSecond));
390    assertThat(record.get(Field.FILTERED_READ_REQUEST_COUNT_PER_SECOND).asLong(),
391      is(filteredReadRequestsCount));
392    assertThat(record.get(Field.HOST_ADDRESS).asString(), is(hostAddress));
393    assertThat(record.get(Field.USER_NAME).asString(), is(userName));
394    assertThat(record.get(Field.CLIENT_VERSION).asString(), is(clientVersion));
395    assertThat(record.get(Field.SERVICE_NAME).asString(), is(serviceName));
396    assertThat(record.get(Field.USER_COUNT).asInt(), is(1));
397  }
398
399  private static void assertRecordInTableMode(Record record, long requestCountPerSecond,
400    long readRequestCountPerSecond, long filteredReadRequestCountPerSecond,
401    long writeCountRequestPerSecond, Size storeFileSize, Size uncompressedStoreFileSize,
402    int numStoreFiles, Size memStoreSize, int regionCount) {
403    assertThat(record.size(), is(11));
404    assertThat(record.get(Field.REQUEST_COUNT_PER_SECOND).asLong(), is(requestCountPerSecond));
405    assertThat(record.get(Field.READ_REQUEST_COUNT_PER_SECOND).asLong(),
406      is(readRequestCountPerSecond));
407    assertThat(record.get(Field.FILTERED_READ_REQUEST_COUNT_PER_SECOND).asLong(),
408      is(filteredReadRequestCountPerSecond));
409    assertThat(record.get(Field.WRITE_REQUEST_COUNT_PER_SECOND).asLong(),
410      is(writeCountRequestPerSecond));
411    assertThat(record.get(Field.STORE_FILE_SIZE).asSize(), is(storeFileSize));
412    assertThat(record.get(Field.UNCOMPRESSED_STORE_FILE_SIZE).asSize(),
413      is(uncompressedStoreFileSize));
414    assertThat(record.get(Field.NUM_STORE_FILES).asInt(), is(numStoreFiles));
415    assertThat(record.get(Field.MEM_STORE_SIZE).asSize(), is(memStoreSize));
416    assertThat(record.get(Field.REGION_COUNT).asInt(), is(regionCount));
417  }
418
419  public static void assertRecordsInRegionServerMode(List<Record> records) {
420    assertThat(records.size(), is(2));
421
422    for (Record record : records) {
423      switch (record.get(Field.REGION_SERVER).asString()) {
424        case "host1:1000":
425          assertRecordInRegionServerMode(record, "host1.apache.com,1000,1", 0L, 0L, 0L, 0L,
426            new Size(600, Size.Unit.MEGABYTE), new Size(1200, Size.Unit.MEGABYTE), 6,
427            new Size(600, Size.Unit.MEGABYTE), 3, new Size(100, Size.Unit.MEGABYTE),
428            new Size(200, Size.Unit.MEGABYTE));
429          break;
430
431        case "host2:1001":
432          assertRecordInRegionServerMode(record, "host2.apache.com,1001,2", 0L, 0L, 0L, 0L,
433            new Size(600, Size.Unit.MEGABYTE), new Size(1200, Size.Unit.MEGABYTE), 6,
434            new Size(600, Size.Unit.MEGABYTE), 3, new Size(16, Size.Unit.GIGABYTE),
435            new Size(32, Size.Unit.GIGABYTE));
436          break;
437
438        default:
439          fail();
440      }
441    }
442  }
443
444  private static void assertRecordInRegionServerMode(Record record, String longRegionServer,
445    long requestCountPerSecond, long readRequestCountPerSecond,
446    long filteredReadRequestCountPerSecond, long writeCountRequestPerSecond, Size storeFileSize,
447    Size uncompressedStoreFileSize, int numStoreFiles, Size memStoreSize, int regionCount,
448    Size usedHeapSize, Size maxHeapSize) {
449    assertThat(record.size(), is(13));
450    assertThat(record.get(Field.LONG_REGION_SERVER).asString(), is(longRegionServer));
451    assertThat(record.get(Field.REQUEST_COUNT_PER_SECOND).asLong(), is(requestCountPerSecond));
452    assertThat(record.get(Field.READ_REQUEST_COUNT_PER_SECOND).asLong(),
453      is(readRequestCountPerSecond));
454    assertThat(record.get(Field.FILTERED_READ_REQUEST_COUNT_PER_SECOND).asLong(),
455      is(filteredReadRequestCountPerSecond));
456    assertThat(record.get(Field.WRITE_REQUEST_COUNT_PER_SECOND).asLong(),
457      is(writeCountRequestPerSecond));
458    assertThat(record.get(Field.STORE_FILE_SIZE).asSize(), is(storeFileSize));
459    assertThat(record.get(Field.UNCOMPRESSED_STORE_FILE_SIZE).asSize(),
460      is(uncompressedStoreFileSize));
461    assertThat(record.get(Field.NUM_STORE_FILES).asInt(), is(numStoreFiles));
462    assertThat(record.get(Field.MEM_STORE_SIZE).asSize(), is(memStoreSize));
463    assertThat(record.get(Field.REGION_COUNT).asInt(), is(regionCount));
464    assertThat(record.get(Field.USED_HEAP_SIZE).asSize(), is(usedHeapSize));
465    assertThat(record.get(Field.MAX_HEAP_SIZE).asSize(), is(maxHeapSize));
466  }
467
468  public static void assertSummary(Summary summary) {
469    assertThat(summary.getVersion(), is("3.0.0-SNAPSHOT"));
470    assertThat(summary.getClusterId(), is("01234567-89ab-cdef-0123-456789abcdef"));
471    assertThat(summary.getServers(), is(3));
472    assertThat(summary.getLiveServers(), is(2));
473    assertThat(summary.getDeadServers(), is(1));
474    assertThat(summary.getRegionCount(), is(6));
475    assertThat(summary.getRitCount(), is(1));
476    assertThat(summary.getAverageLoad(), is(3.0));
477    assertThat(summary.getAggregateRequestPerSecond(), is(300L));
478  }
479}