Java MetaReader.getTableRegionsAndLocations方法代码示例

import org.apache.hadoop.hbase.catalog.MetaReader; //导入方法依赖的package包/类
private void waitAndVerifyRegionNum(HMaster master, TableName tablename,
    int expectedRegionNum) throws Exception {
  List<Pair<HRegionInfo, ServerName>> tableRegionsInMeta;
  List<HRegionInfo> tableRegionsInMaster;
  long timeout = System.currentTimeMillis() + waitTime;
  while (System.currentTimeMillis() < timeout) {
    tableRegionsInMeta = MetaReader.getTableRegionsAndLocations(
        master.getCatalogTracker(), tablename);
    tableRegionsInMaster = master.getAssignmentManager().getRegionStates()
        .getRegionsOfTable(tablename);
    if (tableRegionsInMeta.size() == expectedRegionNum
        && tableRegionsInMaster.size() == expectedRegionNum) {
      break;
    }
    Thread.sleep(250);
  }

  tableRegionsInMeta = MetaReader.getTableRegionsAndLocations(
      master.getCatalogTracker(), tablename);
  LOG.info("Regions after merge:" + Joiner.on(',').join(tableRegionsInMeta));
  assertEquals(expectedRegionNum, tableRegionsInMeta.size());
}
 

import org.apache.hadoop.hbase.catalog.MetaReader; //导入方法依赖的package包/类
public static List<Pair<byte[], ServerName>> getStartKeysAndLocations(HMaster master,
    String tableName) throws IOException, InterruptedException {

  List<Pair<HRegionInfo, ServerName>> tableRegionsAndLocations =
      MetaReader.getTableRegionsAndLocations(master.getCatalogTracker(),
        TableName.valueOf(tableName));
  List<Pair<byte[], ServerName>> startKeyAndLocationPairs =
      new ArrayList<Pair<byte[], ServerName>>(tableRegionsAndLocations.size());
  Pair<byte[], ServerName> startKeyAndLocation = null;
  for (Pair<HRegionInfo, ServerName> regionAndLocation : tableRegionsAndLocations) {
    startKeyAndLocation =
        new Pair<byte[], ServerName>(regionAndLocation.getFirst().getStartKey(),
            regionAndLocation.getSecond());
    startKeyAndLocationPairs.add(startKeyAndLocation);
  }
  return startKeyAndLocationPairs;

}
 

import org.apache.hadoop.hbase.catalog.MetaReader; //导入方法依赖的package包/类
private List<Pair<byte[], ServerName>> getStartKeysAndLocations(HMaster master, String tableName)
    throws IOException, InterruptedException {

  List<Pair<HRegionInfo, ServerName>> tableRegionsAndLocations =
      MetaReader.getTableRegionsAndLocations(master.getCatalogTracker(),
        TableName.valueOf(tableName));
  List<Pair<byte[], ServerName>> startKeyAndLocationPairs =
      new ArrayList<Pair<byte[], ServerName>>(tableRegionsAndLocations.size());
  Pair<byte[], ServerName> startKeyAndLocation = null;
  for (Pair<HRegionInfo, ServerName> regionAndLocation : tableRegionsAndLocations) {
    startKeyAndLocation =
        new Pair<byte[], ServerName>(regionAndLocation.getFirst().getStartKey(),
            regionAndLocation.getSecond());
    startKeyAndLocationPairs.add(startKeyAndLocation);
  }
  return startKeyAndLocationPairs;

}
 

import org.apache.hadoop.hbase.catalog.MetaReader; //导入方法依赖的package包/类
/**
 * Flush a table or an individual region. Synchronous operation.
 * @param tableNameOrRegionName table or region to flush
 * @throws IOException if a remote or network exception occurs
 * @throws InterruptedException
 */
public void flush(final byte[] tableNameOrRegionName) throws IOException, InterruptedException {
  CatalogTracker ct = getCatalogTracker();
  try {
    Pair<HRegionInfo, ServerName> regionServerPair = getRegion(tableNameOrRegionName, ct);
    if (regionServerPair != null) {
      if (regionServerPair.getSecond() == null) {
        throw new NoServerForRegionException(Bytes.toStringBinary(tableNameOrRegionName));
      } else {
        flush(regionServerPair.getSecond(), regionServerPair.getFirst());
      }
    } else {
      final String tableName = tableNameString(tableNameOrRegionName, ct);
      List<Pair<HRegionInfo, ServerName>> pairs = MetaReader.getTableRegionsAndLocations(ct,
        tableName);
      for (Pair<HRegionInfo, ServerName> pair : pairs) {
        if (pair.getFirst().isOffline()) continue;
        if (pair.getSecond() == null) continue;
        try {
          flush(pair.getSecond(), pair.getFirst());
        } catch (NotServingRegionException e) {
          if (LOG.isDebugEnabled()) {
            LOG.debug("Trying to flush " + pair.getFirst() + ": "
                + StringUtils.stringifyException(e));
          }
        }
      }
    }
  } finally {
    cleanupCatalogTracker(ct);
  }
}
 

import org.apache.hadoop.hbase.catalog.MetaReader; //导入方法依赖的package包/类
/**
 * Compact a table or an individual region. Asynchronous operation.
 * @param tableNameOrRegionName table or region to compact
 * @param columnFamily column family within a table or region
 * @param major True if we are to do a major compaction.
 * @throws IOException if a remote or network exception occurs
 * @throws InterruptedException
 */
private void compact(final byte[] tableNameOrRegionName, final byte[] columnFamily,
    final boolean major) throws IOException, InterruptedException {
  CatalogTracker ct = getCatalogTracker();
  try {
    Pair<HRegionInfo, ServerName> regionServerPair = getRegion(tableNameOrRegionName, ct);
    if (regionServerPair != null) {
      if (regionServerPair.getSecond() == null) {
        throw new NoServerForRegionException(Bytes.toStringBinary(tableNameOrRegionName));
      } else {
        compact(regionServerPair.getSecond(), regionServerPair.getFirst(), major, columnFamily);
      }
    } else {
      final String tableName = tableNameString(tableNameOrRegionName, ct);
      List<Pair<HRegionInfo, ServerName>> pairs = MetaReader.getTableRegionsAndLocations(ct,
        tableName);
      for (Pair<HRegionInfo, ServerName> pair : pairs) {
        if (pair.getFirst().isOffline()) continue;
        if (pair.getSecond() == null) continue;
        try {
          compact(pair.getSecond(), pair.getFirst(), major, columnFamily);
        } catch (NotServingRegionException e) {
          if (LOG.isDebugEnabled()) {
            LOG.debug("Trying to" + (major ? " major" : "") + " compact " + pair.getFirst()
                + ": " + StringUtils.stringifyException(e));
          }
        }
      }
    }
  } finally {
    cleanupCatalogTracker(ct);
  }
}
 

import org.apache.hadoop.hbase.catalog.MetaReader; //导入方法依赖的package包/类
/**
 * Split a table or an individual region. Asynchronous operation.
 * @param tableNameOrRegionName table to region to split
 * @param splitPoint the explicit position to split on
 * @throws IOException if a remote or network exception occurs
 * @throws InterruptedException interrupt exception occurred
 */
public void split(final byte[] tableNameOrRegionName, final byte[] splitPoint)
    throws IOException, InterruptedException {
  CatalogTracker ct = getCatalogTracker();
  try {
    Pair<HRegionInfo, ServerName> regionServerPair = getRegion(tableNameOrRegionName, ct);
    if (regionServerPair != null) {
      if (regionServerPair.getSecond() == null) {
        throw new NoServerForRegionException(Bytes.toStringBinary(tableNameOrRegionName));
      } else {
        split(regionServerPair.getSecond(), regionServerPair.getFirst(), splitPoint);
      }
    } else {
      final String tableName = tableNameString(tableNameOrRegionName, ct);
      List<Pair<HRegionInfo, ServerName>> pairs = MetaReader.getTableRegionsAndLocations(ct,
        tableName);
      for (Pair<HRegionInfo, ServerName> pair : pairs) {
        // May not be a server for a particular row
        if (pair.getSecond() == null) continue;
        HRegionInfo r = pair.getFirst();
        // check for parents
        if (r.isSplitParent()) continue;
        // if a split point given, only split that particular region
        if (splitPoint != null && !r.containsRow(splitPoint)) continue;
        // call out to region server to do split now
        split(pair.getSecond(), pair.getFirst(), splitPoint);
      }
    }
  } finally {
    cleanupCatalogTracker(ct);
  }
}
 

import org.apache.hadoop.hbase.catalog.MetaReader; //导入方法依赖的package包/类
private void handleEnableTable() throws IOException, KeeperException, InterruptedException {
  // I could check table is disabling and if so, not enable but require
  // that user first finish disabling but that might be obnoxious.

  // Set table enabling flag up in zk.
  this.assignmentManager.getZKTable().setEnablingTable(this.tableNameStr);
  boolean done = false;
  // Get the regions of this table. We're done when all listed
  // tables are onlined.
  List<Pair<HRegionInfo, ServerName>> tableRegionsAndLocations = MetaReader
      .getTableRegionsAndLocations(this.ct, tableName, true);
  int countOfRegionsInTable = tableRegionsAndLocations.size();
  List<HRegionInfo> regions = regionsToAssignWithServerName(tableRegionsAndLocations);
  int regionsCount = regions.size();
  if (regionsCount == 0) {
    done = true;
  }
  LOG.info("Table has " + countOfRegionsInTable + " regions of which " +
    regionsCount + " are offline.");
  BulkEnabler bd = new BulkEnabler(this.server, regions, countOfRegionsInTable, true);
  try {
    if (bd.bulkAssign()) {
      done = true;
    }
  } catch (InterruptedException e) {
    LOG.warn("Enable was interrupted");
    // Preserve the interrupt.
    Thread.currentThread().interrupt();
  }
  // Flip the table to enabled.
  if (done) this.assignmentManager.getZKTable().setEnabledTable(
    this.tableNameStr);
  LOG.info("Enabled table is done=" + done);
}
 

import org.apache.hadoop.hbase.catalog.MetaReader; //导入方法依赖的package包/类
private PairOfSameType<HRegionInfo> requestMergeRegion(
    HMaster master, TableName tablename,
    int regionAnum, int regionBnum) throws Exception {
  List<Pair<HRegionInfo, ServerName>> tableRegions = MetaReader
      .getTableRegionsAndLocations(master.getCatalogTracker(),
          tablename);
  HRegionInfo regionA = tableRegions.get(regionAnum).getFirst();
  HRegionInfo regionB = tableRegions.get(regionBnum).getFirst();
  TEST_UTIL.getHBaseAdmin().mergeRegions(
    regionA.getEncodedNameAsBytes(),
    regionB.getEncodedNameAsBytes(), false);
  return new PairOfSameType<HRegionInfo>(regionA, regionB);
}
 

import org.apache.hadoop.hbase.catalog.MetaReader; //导入方法依赖的package包/类
private HTable createTableAndLoadData(HMaster master, TableName tablename,
    int numRegions) throws Exception {
  assertTrue("ROWSIZE must > numregions:" + numRegions, ROWSIZE > numRegions);
  byte[][] splitRows = new byte[numRegions - 1][];
  for (int i = 0; i < splitRows.length; i++) {
    splitRows[i] = ROWS[(i + 1) * ROWSIZE / numRegions];
  }

  HTable table = TEST_UTIL.createTable(tablename, FAMILYNAME, splitRows);
  loadData(table);
  verifyRowCount(table, ROWSIZE);

  // sleep here is an ugly hack to allow region transitions to finish
  long timeout = System.currentTimeMillis() + waitTime;
  List<Pair<HRegionInfo, ServerName>> tableRegions;
  while (System.currentTimeMillis() < timeout) {
    tableRegions = MetaReader.getTableRegionsAndLocations(
        master.getCatalogTracker(), tablename);
    if (tableRegions.size() == numRegions)
      break;
    Thread.sleep(250);
  }

  tableRegions = MetaReader.getTableRegionsAndLocations(
      master.getCatalogTracker(), tablename);
  LOG.info("Regions after load: " + Joiner.on(',').join(tableRegions));
  assertEquals(numRegions, tableRegions.size());
  return table;
}
 

import org.apache.hadoop.hbase.catalog.MetaReader; //导入方法依赖的package包/类
/**
 * Flush a table or an individual region.
 * Synchronous operation.
 *
 * @param tableNameOrRegionName table or region to flush
 * @throws IOException if a remote or network exception occurs
 * @throws InterruptedException
 */
public void flush(final byte[] tableNameOrRegionName)
throws IOException, InterruptedException {
  CatalogTracker ct = getCatalogTracker();
  try {
    Pair<HRegionInfo, ServerName> regionServerPair
      = getRegion(tableNameOrRegionName, ct);
    if (regionServerPair != null) {
      if (regionServerPair.getSecond() == null) {
        throw new NoServerForRegionException(Bytes.toStringBinary(tableNameOrRegionName));
      } else {
        flush(regionServerPair.getSecond(), regionServerPair.getFirst());
      }
    } else {
      final TableName tableName = checkTableExists(
          TableName.valueOf(tableNameOrRegionName), ct);
      List<Pair<HRegionInfo, ServerName>> pairs =
        MetaReader.getTableRegionsAndLocations(ct,
            tableName);
      for (Pair<HRegionInfo, ServerName> pair: pairs) {
        if (pair.getFirst().isOffline()) continue;
        if (pair.getSecond() == null) continue;
        try {
          flush(pair.getSecond(), pair.getFirst());
        } catch (NotServingRegionException e) {
          if (LOG.isDebugEnabled()) {
            LOG.debug("Trying to flush " + pair.getFirst() + ": " +
              StringUtils.stringifyException(e));
          }
        }
      }
    }
  } finally {
    cleanupCatalogTracker(ct);
  }
}
 

import org.apache.hadoop.hbase.catalog.MetaReader; //导入方法依赖的package包/类
/**
 * Compact a table or an individual region.
 * Asynchronous operation.
 *
 * @param tableNameOrRegionName table or region to compact
 * @param columnFamily column family within a table or region
 * @param major True if we are to do a major compaction.
 * @throws IOException if a remote or network exception occurs
 * @throws InterruptedException
 */
private void compact(final byte[] tableNameOrRegionName,
  final byte[] columnFamily,final boolean major)
throws IOException, InterruptedException {
  CatalogTracker ct = getCatalogTracker();
  try {
    Pair<HRegionInfo, ServerName> regionServerPair
      = getRegion(tableNameOrRegionName, ct);
    if (regionServerPair != null) {
      if (regionServerPair.getSecond() == null) {
        throw new NoServerForRegionException(Bytes.toStringBinary(tableNameOrRegionName));
      } else {
        compact(regionServerPair.getSecond(), regionServerPair.getFirst(), major, columnFamily);
      }
    } else {
      final TableName tableName =
          checkTableExists(TableName.valueOf(tableNameOrRegionName), ct);
      List<Pair<HRegionInfo, ServerName>> pairs =
        MetaReader.getTableRegionsAndLocations(ct,
            tableName);
      for (Pair<HRegionInfo, ServerName> pair: pairs) {
        if (pair.getFirst().isOffline()) continue;
        if (pair.getSecond() == null) continue;
        try {
          compact(pair.getSecond(), pair.getFirst(), major, columnFamily);
        } catch (NotServingRegionException e) {
          if (LOG.isDebugEnabled()) {
            LOG.debug("Trying to" + (major ? " major" : "") + " compact " +
              pair.getFirst() + ": " +
              StringUtils.stringifyException(e));
          }
        }
      }
    }
  } finally {
    cleanupCatalogTracker(ct);
  }
}
 

import org.apache.hadoop.hbase.catalog.MetaReader; //导入方法依赖的package包/类
/**
 * Split a table or an individual region.
 * Asynchronous operation.
 *
 * @param tableNameOrRegionName table to region to split
 * @param splitPoint the explicit position to split on
 * @throws IOException if a remote or network exception occurs
 * @throws InterruptedException interrupt exception occurred
 */
public void split(final byte[] tableNameOrRegionName,
    final byte [] splitPoint) throws IOException, InterruptedException {
  CatalogTracker ct = getCatalogTracker();
  try {
    Pair<HRegionInfo, ServerName> regionServerPair
      = getRegion(tableNameOrRegionName, ct);
    if (regionServerPair != null) {
      if (regionServerPair.getSecond() == null) {
          throw new NoServerForRegionException(Bytes.toStringBinary(tableNameOrRegionName));
      } else {
        split(regionServerPair.getSecond(), regionServerPair.getFirst(), splitPoint);
      }
    } else {
      final TableName tableName =
          checkTableExists(TableName.valueOf(tableNameOrRegionName), ct);
      List<Pair<HRegionInfo, ServerName>> pairs =
        MetaReader.getTableRegionsAndLocations(ct,
            tableName);
      for (Pair<HRegionInfo, ServerName> pair: pairs) {
        // May not be a server for a particular row
        if (pair.getSecond() == null) continue;
        HRegionInfo r = pair.getFirst();
        // check for parents
        if (r.isSplitParent()) continue;
        // if a split point given, only split that particular region
        if (splitPoint != null && !r.containsRow(splitPoint)) continue;
        // call out to region server to do split now
        split(pair.getSecond(), pair.getFirst(), splitPoint);
      }
    }
  } finally {
    cleanupCatalogTracker(ct);
  }
}
 

import org.apache.hadoop.hbase.catalog.MetaReader; //导入方法依赖的package包/类
/**
 * Flush a table or an individual region.
 * Synchronous operation.
 *
 * @param tableNameOrRegionName table or region to flush
 * @throws IOException if a remote or network exception occurs
 * @throws InterruptedException
 */
public void flush(final byte [] tableNameOrRegionName)
throws IOException, InterruptedException {
  CatalogTracker ct = getCatalogTracker();
  try {
    Pair<HRegionInfo, ServerName> regionServerPair
      = getRegion(tableNameOrRegionName, ct);
    if (regionServerPair != null) {
      if (regionServerPair.getSecond() == null) {
        throw new NoServerForRegionException(Bytes.toStringBinary(tableNameOrRegionName));
      } else {
        flush(regionServerPair.getSecond(), regionServerPair.getFirst());
      }
    } else {
      final String tableName = tableNameString(tableNameOrRegionName, ct);
      List<Pair<HRegionInfo, ServerName>> pairs =
        MetaReader.getTableRegionsAndLocations(ct,
            tableName);
      for (Pair<HRegionInfo, ServerName> pair: pairs) {
        if (pair.getFirst().isOffline()) continue;
        if (pair.getSecond() == null) continue;
        try {
          flush(pair.getSecond(), pair.getFirst());
        } catch (NotServingRegionException e) {
          if (LOG.isDebugEnabled()) {
            LOG.debug("Trying to flush " + pair.getFirst() + ": " +
              StringUtils.stringifyException(e));
          }
        }
      }
    }
  } finally {
    cleanupCatalogTracker(ct);
  }
}
 

import org.apache.hadoop.hbase.catalog.MetaReader; //导入方法依赖的package包/类
/**
 * Compact a table or an individual region.
 * Asynchronous operation.
 *
 * @param tableNameOrRegionName table or region to compact
 * @param columnFamily column family within a table or region
 * @param major True if we are to do a major compaction.
 * @throws IOException if a remote or network exception occurs
 * @throws InterruptedException
 */
private void compact(final byte [] tableNameOrRegionName,
  final byte[] columnFamily, final boolean major)
throws IOException, InterruptedException {
  CatalogTracker ct = getCatalogTracker();
  try {
    Pair<HRegionInfo, ServerName> regionServerPair
      = getRegion(tableNameOrRegionName, ct);
    if (regionServerPair != null) {
      if (regionServerPair.getSecond() == null) {
        throw new NoServerForRegionException(Bytes.toStringBinary(tableNameOrRegionName));
      } else {
        compact(regionServerPair.getSecond(), regionServerPair.getFirst(), major, columnFamily);
      }
    } else {
      final String tableName = tableNameString(tableNameOrRegionName, ct);
      List<Pair<HRegionInfo, ServerName>> pairs =
        MetaReader.getTableRegionsAndLocations(ct,
            tableName);
      for (Pair<HRegionInfo, ServerName> pair: pairs) {
        if (pair.getFirst().isOffline()) continue;
        if (pair.getSecond() == null) continue;
        try {
          compact(pair.getSecond(), pair.getFirst(), major, columnFamily);
        } catch (NotServingRegionException e) {
          if (LOG.isDebugEnabled()) {
            LOG.debug("Trying to" + (major ? " major" : "") + " compact " +
              pair.getFirst() + ": " +
              StringUtils.stringifyException(e));
          }
        }
      }
    }
  } finally {
    cleanupCatalogTracker(ct);
  }
}
 

import org.apache.hadoop.hbase.catalog.MetaReader; //导入方法依赖的package包/类
/**
 * Split a table or an individual region.
 * Asynchronous operation.
 *
 * @param tableNameOrRegionName table to region to split
 * @param splitPoint the explicit position to split on
 * @throws IOException if a remote or network exception occurs
 * @throws InterruptedException interrupt exception occurred
 */
public void split(final byte [] tableNameOrRegionName,
    final byte [] splitPoint) throws IOException, InterruptedException {
  CatalogTracker ct = getCatalogTracker();
  try {
    Pair<HRegionInfo, ServerName> regionServerPair
      = getRegion(tableNameOrRegionName, ct);
    if (regionServerPair != null) {
      if (regionServerPair.getSecond() == null) {
          throw new NoServerForRegionException(Bytes.toStringBinary(tableNameOrRegionName));
      } else {
        split(regionServerPair.getSecond(), regionServerPair.getFirst(), splitPoint);
      }
    } else {
      final String tableName = tableNameString(tableNameOrRegionName, ct);
      List<Pair<HRegionInfo, ServerName>> pairs =
        MetaReader.getTableRegionsAndLocations(ct,
            tableName);
      for (Pair<HRegionInfo, ServerName> pair: pairs) {
        // May not be a server for a particular row
        if (pair.getSecond() == null) continue;
        HRegionInfo r = pair.getFirst();
        // check for parents
        if (r.isSplitParent()) continue;
        // if a split point given, only split that particular region
        if (splitPoint != null && !r.containsRow(splitPoint)) continue;
        // call out to region server to do split now
        split(pair.getSecond(), pair.getFirst(), splitPoint);
      }
    }
  } finally {
    cleanupCatalogTracker(ct);
  }
}