Java Admin.move方法代碼示例

import org.apache.hadoop.hbase.client.Admin; //導入方法依賴的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 Admin admin,
    final HRegionInfo hri)
throws IOException, 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 < 20; 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(1000);
  }
  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.Admin; //導入方法依賴的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");
  Admin admin = this.context.getHBaseIntegrationTestingUtility().getHBaseAdmin();
  for (byte[] victimRegion : victimRegions) {
    // Don't keep moving regions if we're
    // trying to stop the monkey.
    if (context.isStopping()) {
      break;
    }
    int targetIx = RandomUtils.nextInt(toServers.size());
    admin.move(victimRegion, Bytes.toBytes(toServers.get(targetIx).getServerName()));
  }
}
 

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

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

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

  // Move region to the new RegionServer.
  List<HRegionLocation> regions;
  try (RegionLocator locator = systemUserConnection.getRegionLocator(TEST_TABLE2)) {
    regions = locator.getAllRegionLocations();
  }
  HRegionLocation location = regions.get(0);
  final HRegionInfo hri = location.getRegionInfo();
  final ServerName server = location.getServerName();
  try (HTable table = (HTable) systemUserConnection.getTable(TEST_TABLE2)) {
    AccessTestAction moveAction = new AccessTestAction() {
      @Override
      public Object run() throws Exception {
        admin.move(hri.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);
  }
}
 

import org.apache.hadoop.hbase.client.Admin; //導入方法依賴的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");
  Admin 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.Admin; //導入方法依賴的package包/類
@Override
public void perform() throws Exception {
  if (sleepTime > 0) {
    Thread.sleep(sleepTime);
  }

  Admin 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(tableName);
  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) {

    // Don't try the move if we're stopping
    if (context.isStopping()) {
      return;
    }

    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;
    }
  }
}