Java HBaseAdmin.move方法代码示例

import org.apache.hadoop.hbase.client.HBaseAdmin; //导入方法依赖的package包/类
protected void unbalanceRegions(ClusterStatus clusterStatus,
    List<ServerName> fromServers, List<ServerName> toServers,
    double fractionOfRegions) throws Exception {
  List<byte[]> victimRegions = new LinkedList<byte[]>();
  for (ServerName server : fromServers) {
    ServerLoad serverLoad = clusterStatus.getLoad(server);
    // Ugh.
    List<byte[]> regions = new LinkedList<byte[]>(serverLoad.getRegionsLoad().keySet());
    int victimRegionCount = (int)Math.ceil(fractionOfRegions * regions.size());
    LOG.debug("Removing " + victimRegionCount + " regions from " + server.getServerName());
    for (int i = 0; i < victimRegionCount; ++i) {
      int victimIx = RandomUtils.nextInt(regions.size());
      String regionId = HRegionInfo.encodeRegionName(regions.remove(victimIx));
      victimRegions.add(Bytes.toBytes(regionId));
    }
  }

  LOG.info("Moving " + victimRegions.size() + " regions from " + fromServers.size()
      + " servers to " + toServers.size() + " different servers");
  HBaseAdmin admin = this.context.getHBaseIntegrationTestingUtility().getHBaseAdmin();
  for (byte[] victimRegion : victimRegions) {
    int targetIx = RandomUtils.nextInt(toServers.size());
    admin.move(victimRegion, Bytes.toBytes(toServers.get(targetIx).getServerName()));
  }
}
 

import org.apache.hadoop.hbase.client.HBaseAdmin; //导入方法依赖的package包/类
/**
 * Ensure single table region is not on same server as the single hbase:meta table
 * region.
 * @param admin
 * @param hri
 * @return Index of the server hosting the single table region
 * @throws UnknownRegionException
 * @throws MasterNotRunningException
 * @throws org.apache.hadoop.hbase.ZooKeeperConnectionException
 * @throws InterruptedException
 */
private int ensureTableRegionNotOnSameServerAsMeta(final HBaseAdmin admin,
    final HRegionInfo hri)
throws HBaseIOException, MasterNotRunningException,
ZooKeeperConnectionException, InterruptedException {
  // Now make sure that the table region is not on same server as that hosting
  // hbase:meta  We don't want hbase:meta replay polluting our test when we later crash
  // the table region serving server.
  int metaServerIndex = cluster.getServerWithMeta();
  assertTrue(metaServerIndex != -1);
  HRegionServer metaRegionServer = cluster.getRegionServer(metaServerIndex);
  int tableRegionIndex = cluster.getServerWith(hri.getRegionName());
  assertTrue(tableRegionIndex != -1);
  HRegionServer tableRegionServer = cluster.getRegionServer(tableRegionIndex);
  if (metaRegionServer.getServerName().equals(tableRegionServer.getServerName())) {
    HRegionServer hrs = getOtherRegionServer(cluster, metaRegionServer);
    assertNotNull(hrs);
    assertNotNull(hri);
    LOG.info("Moving " + hri.getRegionNameAsString() + " from " +
      metaRegionServer.getServerName() + " to " +
      hrs.getServerName() + "; metaServerIndex=" + metaServerIndex);
    admin.move(hri.getEncodedNameAsBytes(), Bytes.toBytes(hrs.getServerName().toString()));
  }
  // Wait till table region is up on the server that is NOT carrying hbase:meta.
  for (int i = 0; i < 100; i++) {
    tableRegionIndex = cluster.getServerWith(hri.getRegionName());
    if (tableRegionIndex != -1 && tableRegionIndex != metaServerIndex) break;
    LOG.debug("Waiting on region move off the hbase:meta server; current index " +
      tableRegionIndex + " and metaServerIndex=" + metaServerIndex);
    Thread.sleep(100);
  }
  assertTrue("Region not moved off hbase:meta server", tableRegionIndex != -1
      && tableRegionIndex != metaServerIndex);
  // Verify for sure table region is not on same server as hbase:meta
  tableRegionIndex = cluster.getServerWith(hri.getRegionName());
  assertTrue(tableRegionIndex != -1);
  assertNotSame(metaServerIndex, tableRegionIndex);
  return tableRegionIndex;
}
 

import org.apache.hadoop.hbase.client.HBaseAdmin; //导入方法依赖的package包/类
@Override
public void perform() throws Exception {
  if (sleepTime > 0) {
    Thread.sleep(sleepTime);
  }

  HBaseAdmin admin = this.context.getHBaseIntegrationTestingUtility().getHBaseAdmin();
  Collection<ServerName> serversList = admin.getClusterStatus().getServers();
  ServerName[] servers = serversList.toArray(new ServerName[serversList.size()]);

  LOG.info("Performing action: Move regions of table " + tableName);
  List<HRegionInfo> regions = admin.getTableRegions(tableNameBytes);
  if (regions == null || regions.isEmpty()) {
    LOG.info("Table " + tableName + " doesn't have regions to move");
    return;
  }

  Collections.shuffle(regions);

  long start = System.currentTimeMillis();
  for (HRegionInfo regionInfo:regions) {
    try {
      String destServerName =
        servers[RandomUtils.nextInt(servers.length)].getServerName();
      LOG.debug("Moving " + regionInfo.getRegionNameAsString() + " to " + destServerName);
      admin.move(regionInfo.getEncodedNameAsBytes(), Bytes.toBytes(destServerName));
    } catch (Exception ex) {
      LOG.warn("Move failed, might be caused by other chaos: " + ex.getMessage());
    }
    if (sleepTime > 0) {
      Thread.sleep(sleepTime);
    }

    // put a limit on max num regions. Otherwise, this won't finish
    // with a sleep time of 10sec, 100 regions will finish in 16min
    if (System.currentTimeMillis() - start > maxTime) {
      break;
    }
  }
}
 

import org.apache.hadoop.hbase.client.HBaseAdmin; //导入方法依赖的package包/类
private void collocateRowToDifferentRS(HBaseAdmin admin, HTable table, String rowKey)
    throws IOException, UnknownRegionException, MasterNotRunningException,
    ZooKeeperConnectionException {

  HRegionInfo regionInfo = table.getRegionLocation(rowKey).getRegionInfo();
  int originServerNum = UTIL.getMiniHBaseCluster().getServerWith(regionInfo.getRegionName());
  int targetServerNum = 3 - 1 - originServerNum;
  HRegionServer targetServer = UTIL.getMiniHBaseCluster().getRegionServer(targetServerNum);
  admin.move(regionInfo.getEncodedNameAsBytes(),
    Bytes.toBytes(targetServer.getServerName().getServerName()));
  Threads.sleep(10000);
}
 

import org.apache.hadoop.hbase.client.HBaseAdmin; //导入方法依赖的package包/类
@VisibleForTesting
static void move(Args args, HBaseAdmin admin, String tableName, String targetServerName, String encodedRegionName,
    boolean asynchronous)
    throws IOException, InterruptedException {
    int i;
    for (i = 0; i < Constant.TRY_MAX; i++) {
        try {
            admin.move(encodedRegionName.getBytes(), targetServerName.getBytes());
        } catch (java.lang.reflect.UndeclaredThrowableException ignore) {
        }

        if (asynchronous)
            return;

        if (CommandAdapter.isMetaTable(tableName))
            return;

        if (!isTableEnabled(args, admin, tableName))
            throw new IllegalStateException(Constant.MESSAGE_DISABLED_OR_NOT_FOUND_TABLE);

        if (Util.isMoved(admin, tableName, encodedRegionName, targetServerName)) {
            return;
        }

        Thread.sleep(Constant.WAIT_INTERVAL_MS);

        // assign region again
        if (i >= Constant.TRY_MAX / 2)
            admin.assign(encodedRegionName.getBytes());
    }
    if (i >= Constant.TRY_MAX)
        throw new IllegalStateException(Constant.MESSAGE_CANNOT_MOVE + " - "
            + encodedRegionName + " to " + targetServerName);
}
 

import org.apache.hadoop.hbase.client.HBaseAdmin; //导入方法依赖的package包/类
@Test
public void testMoveRegion() throws IOException, InterruptedException {
  String tableNameString = "testMoveRegion";
  TableName tableName = TableName.valueOf(tableNameString);
  Table t = TEST_UTIL.createTable(tableName, Bytes.toBytes("D"));
  TEST_UTIL.waitUntilAllRegionsAssigned(t.getName());
  HBaseAdmin admin = TEST_UTIL.getHBaseAdmin();
  HRegionInfo regionInfo;
  byte[] row =  Bytes.toBytes("r1");


  for (int i = 0; i < 30; i++) {
    boolean moved = false;
    try (RegionLocator locator = TEST_UTIL.getConnection().getRegionLocator(tableName)) {
      regionInfo = locator.getRegionLocation(row, true).getRegionInfo();
    }

    int currentServerIdx = cluster.getServerWith(regionInfo.getRegionName());
    int destServerIdx = (currentServerIdx +1)% cluster.getLiveRegionServerThreads().size();
    HRegionServer currentServer = cluster.getRegionServer(currentServerIdx);
    HRegionServer destServer = cluster.getRegionServer(destServerIdx);
    byte[] destServerName = Bytes.toBytes(destServer.getServerName().getServerName());


    // Do a put. The counters should be non-zero now
    Put p = new Put(row);
    p.addColumn(Bytes.toBytes("D"), Bytes.toBytes("Zero"), Bytes.toBytes("VALUE"));
    t.put(p);


    MetricsRegionAggregateSource currentAgg = currentServer.getRegion(regionInfo.getRegionName())
        .getMetrics()
        .getSource()
        .getAggregateSource();

    String prefix = "namespace_"+ NamespaceDescriptor.DEFAULT_NAMESPACE_NAME_STR+
        "_table_"+tableNameString +
        "_region_" + regionInfo.getEncodedName()+
        "_metric";

    metricsHelper.assertCounter(prefix + "_mutateCount", 1, currentAgg);


    try {
      admin.move(regionInfo.getEncodedNameAsBytes(), destServerName);
      moved = true;
      Thread.sleep(5000);
    } catch (IOException ioe) {
      moved = false;
    }
    TEST_UTIL.waitUntilAllRegionsAssigned(t.getName());

    if (moved) {
      MetricsRegionAggregateSource destAgg = destServer.getRegion(regionInfo.getRegionName())
          .getMetrics()
          .getSource()
          .getAggregateSource();
      metricsHelper.assertCounter(prefix + "_mutateCount", 0, destAgg);
    }
  }

  TEST_UTIL.deleteTable(tableName);

}
 

import org.apache.hadoop.hbase.client.HBaseAdmin; //导入方法依赖的package包/类
/**
 * Ensure single table region is not on same server as the single .META. table
 * region.
 * @param admin
 * @param hri
 * @return Index of the server hosting the single table region
 * @throws UnknownRegionException
 * @throws MasterNotRunningException
 * @throws ZooKeeperConnectionException
 * @throws InterruptedException
 */
private int ensureTableRegionNotOnSameServerAsMeta(final HBaseAdmin admin,
    final HRegionInfo hri)
throws UnknownRegionException, MasterNotRunningException,
ZooKeeperConnectionException, InterruptedException {
  MiniHBaseCluster cluster = TESTING_UTIL.getMiniHBaseCluster();
  // Now make sure that the table region is not on same server as that hosting
  // .META.  We don't want .META. replay polluting our test when we later crash
  // the table region serving server.
  int metaServerIndex = cluster.getServerWithMeta();
  assertTrue(metaServerIndex != -1);
  HRegionServer metaRegionServer = cluster.getRegionServer(metaServerIndex);
  int tableRegionIndex = cluster.getServerWith(hri.getRegionName());
  assertTrue(tableRegionIndex != -1);
  HRegionServer tableRegionServer = cluster.getRegionServer(tableRegionIndex);
  if (metaRegionServer.getServerName().equals(tableRegionServer.getServerName())) {
    HRegionServer hrs = getOtherRegionServer(cluster, metaRegionServer);
    assertNotNull(hrs);
    assertNotNull(hri);
    LOG.
      info("Moving " + hri.getRegionNameAsString() + " to " +
      hrs.getServerName() + "; metaServerIndex=" + metaServerIndex);
    for (int i = 0; cluster.getMaster().getAssignmentManager()
        .getRegionServerOfRegion(hri) == null
        && i < 100; i++) {
      Thread.sleep(10);
    }
    admin.move(hri.getEncodedNameAsBytes(),
      Bytes.toBytes(hrs.getServerName().toString()));
  }
  // Wait till table region is up on the server that is NOT carrying .META..
  for (int i=0; i<100; i++) {
    tableRegionIndex = cluster.getServerWith(hri.getRegionName());
    if (tableRegionIndex != -1 && tableRegionIndex != metaServerIndex) break;
    LOG.debug("Waiting on region move off the .META. server; current index " +
      tableRegionIndex + " and metaServerIndex=" + metaServerIndex);
    Thread.sleep(100);
  }
  assertTrue("Region not moved off .META. server", tableRegionIndex != -1
      && tableRegionIndex != metaServerIndex);
  // Verify for sure table region is not on same server as .META.
  tableRegionIndex = cluster.getServerWith(hri.getRegionName());
  assertTrue(tableRegionIndex != -1);
  assertNotSame(metaServerIndex, tableRegionIndex);
  return tableRegionIndex;
}
 

import org.apache.hadoop.hbase.client.HBaseAdmin; //导入方法依赖的package包/类
@Test (timeout=180000)
public void testDataCorrectnessReplayingRecoveredEdits() throws Exception {
  final int NUM_MASTERS = 1;
  final int NUM_RS = 3;
  TEST_UTIL.startMiniCluster(NUM_MASTERS, NUM_RS);

  try {
    final byte[] TABLENAME = Bytes
        .toBytes("testDataCorrectnessReplayingRecoveredEdits");
    final byte[] FAMILY = Bytes.toBytes("family");
    MiniHBaseCluster cluster = TEST_UTIL.getHBaseCluster();
    HMaster master = cluster.getMaster();

    // Create table
    HTableDescriptor desc = new HTableDescriptor(TABLENAME);
    desc.addFamily(new HColumnDescriptor(FAMILY));
    HBaseAdmin hbaseAdmin = TEST_UTIL.getHBaseAdmin();
    hbaseAdmin.createTable(desc);

    assertTrue(hbaseAdmin.isTableAvailable(TABLENAME));

    // Put data: r1->v1
    HTable table = new HTable(TEST_UTIL.getConfiguration(), TABLENAME);
    putDataAndVerify(table, "r1", FAMILY, "v1", 1);

    // Move region to target server
    HRegionInfo regionInfo = table.getRegionLocation("r1").getRegionInfo();
    int originServerNum = cluster.getServerWith(regionInfo.getRegionName());
    HRegionServer originServer = cluster.getRegionServer(originServerNum);
    int targetServerNum = (originServerNum + 1) % NUM_RS;
    HRegionServer targetServer = cluster.getRegionServer(targetServerNum);
    assertFalse(originServer.equals(targetServer));

    do {
      Thread.sleep(10);
    } while (!originServer.getServerName().equals(
            cluster.getMaster().getAssignmentManager().getRegionServerOfRegion(regionInfo)));

    hbaseAdmin.move(regionInfo.getEncodedNameAsBytes(),
        Bytes.toBytes(targetServer.getServerName().getServerName()));

    do {
      Thread.sleep(10);
    } while (cluster.getServerWith(regionInfo.getRegionName()) == originServerNum ||
        !targetServer.getServerName().equals(
            cluster.getMaster().getAssignmentManager().getRegionServerOfRegion(regionInfo)));

    // Put data: r2->v2
    putDataAndVerify(table, "r2", FAMILY, "v2", 2);

    // Move region to origin server
    hbaseAdmin.move(regionInfo.getEncodedNameAsBytes(),
        Bytes.toBytes(originServer.getServerName().getServerName()));
    do {
      Thread.sleep(1);
    } while (cluster.getServerWith(regionInfo.getRegionName()) == targetServerNum);

    // Put data: r3->v3
    putDataAndVerify(table, "r3", FAMILY, "v3", 3);

    // Kill target server
    targetServer.kill();
    cluster.getRegionServerThreads().get(targetServerNum).join();
    // Wait until finish processing of shutdown
    while (master.getServerManager().areDeadServersInProgress()) {
      Thread.sleep(5);
    }
    // Kill origin server
    originServer.kill();
    cluster.getRegionServerThreads().get(originServerNum).join();

    // Put data: r4->v4
    putDataAndVerify(table, "r4", FAMILY, "v4", 4);

  } finally {
    TEST_UTIL.shutdownMiniCluster();
  }
}
 

import org.apache.hadoop.hbase.client.HBaseAdmin; //导入方法依赖的package包/类
@Test
public void testGlobalAuthorizationForNewRegisteredRS() throws Exception {
  LOG.debug("Test for global authorization for a new registered RegionServer.");
  MiniHBaseCluster hbaseCluster = TEST_UTIL.getHBaseCluster();

  // Since each RegionServer running on different user, add global
  // permissions for the new user.
  String currentUser = User.getCurrent().getShortName();
  String activeUserForNewRs = currentUser + ".hfs." +
    hbaseCluster.getLiveRegionServerThreads().size();
  grantGlobal(TEST_UTIL, activeUserForNewRs,
    Permission.Action.ADMIN, Permission.Action.CREATE, Permission.Action.READ,
      Permission.Action.WRITE);

  final HBaseAdmin admin = TEST_UTIL.getHBaseAdmin();
  HTableDescriptor htd = new HTableDescriptor(TEST_TABLE2);
  htd.addFamily(new HColumnDescriptor(TEST_FAMILY));
  admin.createTable(htd);

  // Starting a new RegionServer.
  JVMClusterUtil.RegionServerThread newRsThread = hbaseCluster
      .startRegionServer();
  final HRegionServer newRs = newRsThread.getRegionServer();

  // Move region to the new RegionServer.
  final HTable table = new HTable(TEST_UTIL.getConfiguration(), TEST_TABLE2);
  try {
    NavigableMap<HRegionInfo, ServerName> regions = table
        .getRegionLocations();
    final Map.Entry<HRegionInfo, ServerName> firstRegion = regions.entrySet()
        .iterator().next();

    AccessTestAction moveAction = new AccessTestAction() {
      @Override
      public Object run() throws Exception {
        admin.move(firstRegion.getKey().getEncodedNameAsBytes(),
            Bytes.toBytes(newRs.getServerName().getServerName()));
        return null;
      }
    };
    SUPERUSER.runAs(moveAction);

    final int RETRIES_LIMIT = 10;
    int retries = 0;
    while (newRs.getOnlineRegions(TEST_TABLE2).size() < 1 && retries < RETRIES_LIMIT) {
      LOG.debug("Waiting for region to be opened. Already retried " + retries
          + " times.");
      try {
        Thread.sleep(1000);
      } catch (InterruptedException e) {
      }
      retries++;
      if (retries == RETRIES_LIMIT - 1) {
        fail("Retry exhaust for waiting region to be opened.");
      }
    }
    // Verify write permission for user "admin2" who has the global
    // permissions.
    AccessTestAction putAction = new AccessTestAction() {
      @Override
      public Object run() throws Exception {
        Put put = new Put(Bytes.toBytes("test"));
        put.add(TEST_FAMILY, Bytes.toBytes("qual"), Bytes.toBytes("value"));
        table.put(put);
        return null;
      }
    };
    USER_ADMIN.runAs(putAction);
  } finally {
    table.close();
  }
}
 

import org.apache.hadoop.hbase.client.HBaseAdmin; //导入方法依赖的package包/类
/**
 * If a table is deleted, we should not be able to move it anymore.
 * Otherwise, the region will be brought back.
 * @throws Exception
 */
@Test (timeout=50000)
public void testMoveRegionOfDeletedTable() throws Exception {
  TableName table =
      TableName.valueOf("testMoveRegionOfDeletedTable");
  HBaseAdmin admin = TEST_UTIL.getHBaseAdmin();
  try {
    HRegionInfo hri = createTableAndGetOneRegion(table);

    HMaster master = TEST_UTIL.getHBaseCluster().getMaster();
    AssignmentManager am = master.getAssignmentManager();
    RegionStates regionStates = am.getRegionStates();
    ServerName serverName = regionStates.getRegionServerOfRegion(hri);
    ServerName destServerName = null;
    for (int i = 0; i < 3; i++) {
      HRegionServer destServer = TEST_UTIL.getHBaseCluster().getRegionServer(i);
      if (!destServer.getServerName().equals(serverName)) {
        destServerName = destServer.getServerName();
        break;
      }
    }
    assertTrue(destServerName != null
      && !destServerName.equals(serverName));

    TEST_UTIL.deleteTable(table);

    try {
      admin.move(hri.getEncodedNameAsBytes(),
        Bytes.toBytes(destServerName.getServerName()));
      fail("We should not find the region");
    } catch (IOException ioe) {
      assertTrue(ioe instanceof UnknownRegionException);
    }

    am.balance(new RegionPlan(hri, serverName, destServerName));
    assertFalse("The region should not be in transition",
      regionStates.isRegionInTransition(hri));
  } finally {
    if (admin.tableExists(table)) {
      TEST_UTIL.deleteTable(table);
    }
  }
}
 

import org.apache.hadoop.hbase.client.HBaseAdmin; //导入方法依赖的package包/类
@Test (timeout=300000)
public void testDataCorrectnessReplayingRecoveredEdits() throws Exception {
  final int NUM_MASTERS = 1;
  final int NUM_RS = 3;
  TEST_UTIL.startMiniCluster(NUM_MASTERS, NUM_RS);

  try {
    final byte[] TABLENAME = Bytes
        .toBytes("testDataCorrectnessReplayingRecoveredEdits");
    final byte[] FAMILY = Bytes.toBytes("family");
    MiniHBaseCluster cluster = TEST_UTIL.getHBaseCluster();
    HMaster master = cluster.getMaster();

    // Create table
    HTableDescriptor desc = new HTableDescriptor(TableName.valueOf(TABLENAME));
    desc.addFamily(new HColumnDescriptor(FAMILY));
    HBaseAdmin hbaseAdmin = TEST_UTIL.getHBaseAdmin();
    hbaseAdmin.createTable(desc);

    assertTrue(hbaseAdmin.isTableAvailable(TABLENAME));

    // Put data: r1->v1
    Log.info("Loading r1 to v1 into " + Bytes.toString(TABLENAME));
    HTable table = new HTable(TEST_UTIL.getConfiguration(), TABLENAME);
    putDataAndVerify(table, "r1", FAMILY, "v1", 1);

    TEST_UTIL.waitUntilAllRegionsAssigned(table.getName());
    // Move region to target server
    HRegionInfo regionInfo = table.getRegionLocation("r1").getRegionInfo();
    int originServerNum = cluster.getServerWith(regionInfo.getRegionName());
    HRegionServer originServer = cluster.getRegionServer(originServerNum);
    int targetServerNum = (originServerNum + 1) % NUM_RS;
    HRegionServer targetServer = cluster.getRegionServer(targetServerNum);
    assertFalse(originServer.equals(targetServer));

    TEST_UTIL.waitUntilAllRegionsAssigned(table.getName());
    Log.info("Moving " + regionInfo.getEncodedName() + " to " + targetServer.getServerName());
    hbaseAdmin.move(regionInfo.getEncodedNameAsBytes(),
        Bytes.toBytes(targetServer.getServerName().getServerName()));
    do {
      Thread.sleep(1);
    } while (cluster.getServerWith(regionInfo.getRegionName()) == originServerNum);

    // Put data: r2->v2
    Log.info("Loading r2 to v2 into " + Bytes.toString(TABLENAME));
    putDataAndVerify(table, "r2", FAMILY, "v2", 2);

    TEST_UTIL.waitUntilAllRegionsAssigned(table.getName());
    // Move region to origin server
    Log.info("Moving " + regionInfo.getEncodedName() + " to " + originServer.getServerName());
    hbaseAdmin.move(regionInfo.getEncodedNameAsBytes(),
        Bytes.toBytes(originServer.getServerName().getServerName()));
    do {
      Thread.sleep(1);
    } while (cluster.getServerWith(regionInfo.getRegionName()) == targetServerNum);

    // Put data: r3->v3
    Log.info("Loading r3 to v3 into " + Bytes.toString(TABLENAME));
    putDataAndVerify(table, "r3", FAMILY, "v3", 3);

    // Kill target server
    Log.info("Killing target server " + targetServer.getServerName());
    targetServer.kill();
    cluster.getRegionServerThreads().get(targetServerNum).join();
    // Wait until finish processing of shutdown
    while (master.getServerManager().areDeadServersInProgress()) {
      Thread.sleep(5);
    }
    // Kill origin server
    Log.info("Killing origin server " + targetServer.getServerName());
    originServer.kill();
    cluster.getRegionServerThreads().get(originServerNum).join();

    // Put data: r4->v4
    Log.info("Loading r4 to v4 into " + Bytes.toString(TABLENAME));
    putDataAndVerify(table, "r4", FAMILY, "v4", 4);

  } finally {
    TEST_UTIL.shutdownMiniCluster();
  }
}