Java MetaReader类代码示例

import org.apache.hadoop.hbase.catalog.MetaReader; //导入依赖的package包/类
/**
 * Check individual daughter is up in .META.; fixup if its not.
 * @param result The contents of the parent row in .META.
 * @param qualifier Which daughter to check for.
 * @return 1 if the daughter is missing and fixed. Otherwise 0
 * @throws IOException
 */
static int fixupDaughter(final Result result, final byte [] qualifier,
    final AssignmentManager assignmentManager,
    final CatalogTracker catalogTracker)
throws IOException {
  HRegionInfo daughter =
    MetaReader.parseHRegionInfoFromCatalogResult(result, qualifier);
  if (daughter == null) return 0;
  if (isDaughterMissing(catalogTracker, daughter)) {
    LOG.info("Fixup; missing daughter " + daughter.getRegionNameAsString());
    MetaEditor.addDaughter(catalogTracker, daughter, null);

    // TODO: Log WARN if the regiondir does not exist in the fs.  If its not
    // there then something wonky about the split -- things will keep going
    // but could be missing references to parent region.

    // And assign it.
    assignmentManager.assign(daughter, true);
    return 1;
  } else {
    LOG.debug("Daughter " + daughter.getRegionNameAsString() + " present");
  }
  return 0;
}
 

import org.apache.hadoop.hbase.catalog.MetaReader; //导入依赖的package包/类
@Override
public void assign(final byte [] regionName)throws IOException {
  checkInitialized();
  Pair<HRegionInfo, ServerName> pair =
    MetaReader.getRegion(this.catalogTracker, regionName);
  if (pair == null) throw new UnknownRegionException(Bytes.toString(regionName));
  if (cpHost != null) {
    if (cpHost.preAssign(pair.getFirst())) {
      return;
    }
  }
  assignRegion(pair.getFirst());
  if (cpHost != null) {
    cpHost.postAssign(pair.getFirst());
  }
}
 

import org.apache.hadoop.hbase.catalog.MetaReader; //导入依赖的package包/类
@Override
public void unassign(final byte [] regionName, final boolean force)
throws IOException {
  checkInitialized();
  Pair<HRegionInfo, ServerName> pair =
    MetaReader.getRegion(this.catalogTracker, regionName);
  if (pair == null) throw new UnknownRegionException(Bytes.toString(regionName));
  HRegionInfo hri = pair.getFirst();
  if (cpHost != null) {
    if (cpHost.preUnassign(hri, force)) {
      return;
    }
  }
  if (force) {
    this.assignmentManager.regionOffline(hri);
    assignRegion(hri);
  } else {
    this.assignmentManager.unassign(hri, force);
  }
  if (cpHost != null) {
    cpHost.postUnassign(hri, force);
  }
}
 

import org.apache.hadoop.hbase.catalog.MetaReader; //导入依赖的package包/类
public static void blockUntilRegionIsInMeta(HTable metaTable, long timeout, HRegionInfo hri)
    throws IOException, InterruptedException {
  log("blocking until region is in META: " + hri.getRegionNameAsString());
  long start = System.currentTimeMillis();
  while (System.currentTimeMillis() - start < timeout) {
    Result result = getRegionRow(metaTable, hri.getRegionName());
    if (result != null) {
      HRegionInfo info = MetaReader.parseCatalogResult(result).getFirst();
      if (info != null && !info.isOffline()) {
        log("found region in META: " + hri.getRegionNameAsString());
        break;
      }
    }
    Threads.sleep(10);
  }
}
 

import org.apache.hadoop.hbase.catalog.MetaReader; //导入依赖的package包/类
/********************************* Master related hooks **********************************/

  @Override
  public void postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx) throws IOException {
    // Need to create the new system table for labels here
    MasterServices master = ctx.getEnvironment().getMasterServices();
    if (!MetaReader.tableExists(master.getCatalogTracker(), LABELS_TABLE_NAME)) {
      HTableDescriptor labelsTable = new HTableDescriptor(LABELS_TABLE_NAME);
      HColumnDescriptor labelsColumn = new HColumnDescriptor(LABELS_TABLE_FAMILY);
      labelsColumn.setBloomFilterType(BloomType.NONE);
      labelsColumn.setBlockCacheEnabled(false); // We will cache all the labels. No need of normal
                                                 // table block cache.
      labelsTable.addFamily(labelsColumn);
      // Let the "labels" table having only one region always. We are not expecting too many labels in
      // the system.
      labelsTable.setValue(HTableDescriptor.SPLIT_POLICY,
          DisabledRegionSplitPolicy.class.getName());
      labelsTable.setValue(Bytes.toBytes(HConstants.DISALLOW_WRITES_IN_RECOVERING),
          Bytes.toBytes(true));
      master.createTable(labelsTable, null);
    }
  }
 

import org.apache.hadoop.hbase.catalog.MetaReader; //导入依赖的package包/类
/**
 * Use this before submitting a TableReduce job. It will
 * appropriately set up the JobConf.
 *
 * @param table  The output table.
 * @param reducer  The reducer class to use.
 * @param job  The current job configuration to adjust.
 * @param partitioner  Partitioner to use. Pass <code>null</code> to use
 * default partitioner.
 * @param addDependencyJars upload HBase jars and jars for any of the configured
 *           job classes via the distributed cache (tmpjars).
 * @throws IOException When determining the region count fails.
 */
public static void initTableReduceJob(String table,
  Class<? extends TableReduce> reducer, JobConf job, Class partitioner,
  boolean addDependencyJars) throws IOException {
  job.setOutputFormat(TableOutputFormat.class);
  job.setReducerClass(reducer);
  job.set(TableOutputFormat.OUTPUT_TABLE, table);
  job.setOutputKeyClass(ImmutableBytesWritable.class);
  job.setOutputValueClass(Put.class);
  job.setStrings("io.serializations", job.get("io.serializations"),
      MutationSerialization.class.getName(), ResultSerialization.class.getName());
  if (partitioner == HRegionPartitioner.class) {
    job.setPartitionerClass(HRegionPartitioner.class);
    int regions = MetaReader.getRegionCount(HBaseConfiguration.create(job), table);
    if (job.getNumReduceTasks() > regions) {
      job.setNumReduceTasks(regions);
    }
  } else if (partitioner != null) {
    job.setPartitionerClass(partitioner);
  }
  if (addDependencyJars) {
    addDependencyJars(job);
  }
  initCredentials(job);
}
 

import org.apache.hadoop.hbase.catalog.MetaReader; //导入依赖的package包/类
/**
 * Get the HRegionInfo from cache, if not there, from the hbase:meta table
 * @param  regionName
 * @return HRegionInfo for the region
 */
protected HRegionInfo getRegionInfo(final byte [] regionName) {
  String encodedName = HRegionInfo.encodeRegionName(regionName);
  RegionState regionState = regionStates.get(encodedName);
  if (regionState != null) {
    return regionState.getRegion();
  }

  try {
    Pair<HRegionInfo, ServerName> p =
      MetaReader.getRegion(server.getCatalogTracker(), regionName);
    HRegionInfo hri = p == null ? null : p.getFirst();
    if (hri != null) {
      createRegionState(hri);
    }
    return hri;
  } catch (IOException e) {
    server.abort("Aborting because error occoured while reading "
      + Bytes.toStringBinary(regionName) + " from hbase:meta", e);
    return null;
  }
}
 

import org.apache.hadoop.hbase.catalog.MetaReader; //导入依赖的package包/类
/**
 * Checks if the specified region has merge qualifiers, if so, try to clean
 * them
 * @param region
 * @return true if the specified region doesn't have merge qualifier now
 * @throws IOException
 */
public boolean cleanMergeQualifier(final HRegionInfo region)
    throws IOException {
  // Get merge regions if it is a merged region and already has merge
  // qualifier
  Pair<HRegionInfo, HRegionInfo> mergeRegions = MetaReader
      .getRegionsFromMergeQualifier(this.services.getCatalogTracker(),
          region.getRegionName());
  if (mergeRegions == null
      || (mergeRegions.getFirst() == null && mergeRegions.getSecond() == null)) {
    // It doesn't have merge qualifier, no need to clean
    return true;
  }
  // It shouldn't happen, we must insert/delete these two qualifiers together
  if (mergeRegions.getFirst() == null || mergeRegions.getSecond() == null) {
    LOG.error("Merged region " + region.getRegionNameAsString()
        + " has only one merge qualifier in META.");
    return false;
  }
  return cleanMergeRegion(region, mergeRegions.getFirst(),
      mergeRegions.getSecond());
}
 

import org.apache.hadoop.hbase.catalog.MetaReader; //导入依赖的package包/类
/**
 * Used by the client to identify if all regions have the schema updates
 *
 * @param tableName
 * @return Pair indicating the status of the alter command
 * @throws IOException
 */
public Pair<Integer, Integer> getReopenStatus(TableName tableName)
    throws IOException {
  List <HRegionInfo> hris =
    MetaReader.getTableRegions(this.server.getCatalogTracker(), tableName, true);
  Integer pending = 0;
  for (HRegionInfo hri : hris) {
    String name = hri.getEncodedName();
    // no lock concurrent access ok: sequential consistency respected.
    if (regionsToReopen.containsKey(name)
        || regionStates.isRegionInTransition(name)) {
      pending++;
    }
  }
  return new Pair<Integer, Integer>(pending, hris.size());
}
 

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包/类
private void disableAndDeleteTable(MasterServices master, TableName tableName) throws IOException {
  LOG.error(tableName + " already exists.  Disabling and deleting table " + tableName + '.');
  boolean disabled = master.getAssignmentManager().getZKTable().isDisabledTable(tableName);
  if (false == disabled) {
    LOG.info("Disabling table " + tableName + '.');
    new DisableTableHandler(master, tableName, master.getCatalogTracker(),
        master.getAssignmentManager(), master.getTableLockManager(), false).prepare().process();
    if (false == master.getAssignmentManager().getZKTable().isDisabledTable(tableName)) {
      throw new DoNotRetryIOException("Table " + tableName + " not disabled.");
    }
  }
  LOG.info("Disabled table " + tableName + '.');
  LOG.info("Deleting table " + tableName + '.');
  new DeleteTableHandler(tableName, master, master).prepare().process();
  if (true == MetaReader.tableExists(master.getCatalogTracker(), tableName)) {
    throw new DoNotRetryIOException("Table " + tableName + " not  deleted.");
  }
  LOG.info("Deleted table " + tableName + '.');
}
 

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包/类
@Test(timeout = 180000)
public void testIndexTableCreationAlongWithNormalTablesAfterMasterRestart() throws Exception {
  TableName tableName =
      TableName.valueOf("testIndexTableCreationAlongWithNormalTablesAfterMasterRestart");
  HTableDescriptor htd = new HTableDescriptor(tableName);
  admin.createTable(htd);
  MiniHBaseCluster cluster = UTIL.getHBaseCluster();
  cluster.abortMaster(0);
  cluster.waitOnMaster(0);
  HMaster master = cluster.startMaster().getMaster();
  cluster.waitForActiveAndReadyMaster();

  boolean tableExist =
      MetaReader.tableExists(master.getCatalogTracker(),
        TableName.valueOf(IndexUtils.getIndexTableName(tableName)));
  assertFalse("Index table should be not created after master start up.", tableExist);
}
 

import org.apache.hadoop.hbase.catalog.MetaReader; //导入依赖的package包/类
@Override
public void unassign(final byte [] regionName, final boolean force)
throws IOException {
  Pair<HRegionInfo, ServerName> pair =
    MetaReader.getRegion(this.catalogTracker, regionName);
  if (pair == null) throw new UnknownRegionException(Bytes.toString(regionName));
  HRegionInfo hri = pair.getFirst();
  if (cpHost != null) {
    if (cpHost.preUnassign(hri, force)) {
      return;
    }
  }
  if (force) {
    this.assignmentManager.clearRegionFromTransition(hri);
    assignRegion(hri);
  } else {
    this.assignmentManager.unassign(hri, force);
  }
  if (cpHost != null) {
    cpHost.postUnassign(hri, force);
  }
}