Java HRegionInfo類代碼示例

import org.apache.hadoop.hbase.HRegionInfo; //導入依賴的package包/類
/**
 * Create a RegionOpenInfo based on given region info and version of offline node
 */
private static RegionOpenInfo buildRegionOpenInfo(
    final HRegionInfo region, final int versionOfOfflineNode,
    final List<ServerName> favoredNodes, Boolean openForReplay) {
  RegionOpenInfo.Builder builder = RegionOpenInfo.newBuilder();
  builder.setRegion(HRegionInfo.convert(region));
  if (versionOfOfflineNode >= 0) {
    builder.setVersionOfOfflineNode(versionOfOfflineNode);
  }
  if (favoredNodes != null) {
    for (ServerName server : favoredNodes) {
      builder.addFavoredNodes(ProtobufUtil.toServerName(server));
    }
  }
  if(openForReplay != null) {
    builder.setOpenForDistributedLogReplay(openForReplay);
  }
  return builder.build();
}
 

import org.apache.hadoop.hbase.HRegionInfo; //導入依賴的package包/類
/**
 * @param regionsInMeta
 * @return List of regions neither in transition nor assigned.
 * @throws IOException
 */
private static Map<HRegionInfo, ServerName> regionsToAssignWithServerName(
    final MasterProcedureEnv env,
    final List<Pair<HRegionInfo, ServerName>> regionsInMeta) throws IOException {
  Map<HRegionInfo, ServerName> regionsToAssign =
      new HashMap<HRegionInfo, ServerName>(regionsInMeta.size());
  RegionStates regionStates = env.getMasterServices().getAssignmentManager().getRegionStates();
  for (Pair<HRegionInfo, ServerName> regionLocation : regionsInMeta) {
    HRegionInfo hri = regionLocation.getFirst();
    ServerName sn = regionLocation.getSecond();
    if (regionStates.isRegionOffline(hri)) {
      regionsToAssign.put(hri, sn);
    } else {
      if (LOG.isDebugEnabled()) {
        LOG.debug("Skipping assign for the region " + hri + " during enable table "
            + hri.getTable() + " because its already in tranition or assigned.");
      }
    }
  }
  return regionsToAssign;
}
 

import org.apache.hadoop.hbase.HRegionInfo; //導入依賴的package包/類
private Triple<Map<HRegionInfo, ServerName>, FavoredNodeAssignmentHelper, List<HRegionInfo>>
secondaryAndTertiaryRSPlacementHelper(
    int regionCount, Map<String, Integer> rackToServerCount) {
  Map<HRegionInfo, ServerName> primaryRSMap = new HashMap<HRegionInfo, ServerName>();
  List<ServerName> servers = getServersFromRack(rackToServerCount);
  FavoredNodeAssignmentHelper helper = new FavoredNodeAssignmentHelper(servers, rackManager);
  Map<ServerName, List<HRegionInfo>> assignmentMap =
      new HashMap<ServerName, List<HRegionInfo>>();
  helper.initialize();
  // create regions
  List<HRegionInfo> regions = new ArrayList<HRegionInfo>(regionCount);
  for (int i = 0; i < regionCount; i++) {
    HRegionInfo region = new HRegionInfo(TableName.valueOf("foobar"),
        Bytes.toBytes(i), Bytes.toBytes(i + 1));
    regions.add(region);
  }
  // place the regions
  helper.placePrimaryRSAsRoundRobin(assignmentMap, primaryRSMap, regions);
  return new Triple<Map<HRegionInfo, ServerName>, FavoredNodeAssignmentHelper, List<HRegionInfo>>
                 (primaryRSMap, helper, regions);
}
 

import org.apache.hadoop.hbase.HRegionInfo; //導入依賴的package包/類
/**
 * If the input is a region name, it is returned as is. If it's an
 * encoded region name, the corresponding region is found from meta
 * and its region name is returned. If we can't find any region in
 * meta matching the input as either region name or encoded region
 * name, the input is returned as is. We don't throw unknown
 * region exception.
 */
private byte[] getRegionName(
    final byte[] regionNameOrEncodedRegionName) throws IOException {
  if (Bytes.equals(regionNameOrEncodedRegionName,
      HRegionInfo.FIRST_META_REGIONINFO.getRegionName())
        || Bytes.equals(regionNameOrEncodedRegionName,
          HRegionInfo.FIRST_META_REGIONINFO.getEncodedNameAsBytes())) {
    return HRegionInfo.FIRST_META_REGIONINFO.getRegionName();
  }
  byte[] tmp = regionNameOrEncodedRegionName;
  Pair<HRegionInfo, ServerName> regionServerPair = getRegion(regionNameOrEncodedRegionName);
  if (regionServerPair != null && regionServerPair.getFirst() != null) {
    tmp = regionServerPair.getFirst().getRegionName();
  }
  return tmp;
}
 

import org.apache.hadoop.hbase.HRegionInfo; //導入依賴的package包/類
/**
 * Unassign the list of regions. Configuration knobs:
 * hbase.bulk.waitbetween.reopen indicates the number of milliseconds to
 * wait before unassigning another region from this region server
 *
 * @param regions
 * @throws InterruptedException
 */
private void unassign(
    List<HRegionInfo> regions) throws InterruptedException {
  int waitTime = this.server.getConfiguration().getInt(
      "hbase.bulk.waitbetween.reopen", 0);
  RegionStates regionStates = assignmentManager.getRegionStates();
  for (HRegionInfo region : regions) {
    if (server.isStopped()) {
      return;
    }
    if (regionStates.isRegionInTransition(region)) {
      continue;
    }
    assignmentManager.unassign(region, false);
    while (regionStates.isRegionInTransition(region)
        && !server.isStopped()) {
      regionStates.waitForUpdate(100);
    }
    if (waitTime > 0 && !server.isStopped()) {
      Thread.sleep(waitTime);
    }
  }
}
 

import org.apache.hadoop.hbase.HRegionInfo; //導入依賴的package包/類
/**
 * Get the HRegionInfo from cache, if not there, from the hbase:meta table
 * @param  regionName
 * @return HRegionInfo for the region
 */
@SuppressWarnings("deprecation")
protected HRegionInfo getRegionInfo(final byte [] regionName) {
  String encodedName = HRegionInfo.encodeRegionName(regionName);
  RegionState regionState = getRegionState(encodedName);
  if (regionState != null) {
    return regionState.getRegion();
  }

  try {
    Pair<HRegionInfo, ServerName> p =
      MetaTableAccessor.getRegion(server.getConnection(), 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.HRegionInfo; //導入依賴的package包/類
/**
 * @param regionsInMeta
 * @return List of regions neither in transition nor assigned.
 * @throws IOException
 */
private Map<HRegionInfo, ServerName> regionsToAssignWithServerName(
    final List<Pair<HRegionInfo, ServerName>> regionsInMeta) throws IOException {
  Map<HRegionInfo, ServerName> regionsToAssign =
      new HashMap<HRegionInfo, ServerName>(regionsInMeta.size());
  RegionStates regionStates = this.assignmentManager.getRegionStates();
  for (Pair<HRegionInfo, ServerName> regionLocation : regionsInMeta) {
    HRegionInfo hri = regionLocation.getFirst();
    ServerName sn = regionLocation.getSecond();
    if (regionStates.isRegionOffline(hri)) {
      regionsToAssign.put(hri, sn);
    } else {
      if (LOG.isDebugEnabled()) {
        LOG.debug("Skipping assign for the region " + hri + " during enable table "
            + hri.getTable() + " because its already in tranition or assigned.");
      }
    }
  }
  return regionsToAssign;
}
 

import org.apache.hadoop.hbase.HRegionInfo; //導入依賴的package包/類
void start() throws IOException {
  if (!noPersistence) {
    if (server instanceof RegionServerServices) {
      metaRegion = ((RegionServerServices)server).getFromOnlineRegions(
        HRegionInfo.FIRST_META_REGIONINFO.getEncodedName());
    }
    if (metaRegion == null) {
      Configuration conf = server.getConfiguration();
      // Config to determine the no of HConnections to META.
      // A single HConnection should be sufficient in most cases. Only if
      // you are doing lot of writes (>1M) to META,
      // increasing this value might improve the write throughput.
      multiHConnection =
          new MultiHConnection(conf, conf.getInt("hbase.regionstatestore.meta.connection", 1));
    }
  }
  initialized = true;
}
 

import org.apache.hadoop.hbase.HRegionInfo; //導入依賴的package包/類
@Override
public void deserializeStateData(final InputStream stream) throws IOException {
  super.deserializeStateData(stream);

  MasterProcedureProtos.TruncateTableStateData state =
    MasterProcedureProtos.TruncateTableStateData.parseDelimitedFrom(stream);
  user = MasterProcedureUtil.toUserInfo(state.getUserInfo());
  if (state.hasTableSchema()) {
    hTableDescriptor = HTableDescriptor.convert(state.getTableSchema());
    tableName = hTableDescriptor.getTableName();
  } else {
    tableName = ProtobufUtil.toTableName(state.getTableName());
  }
  preserveSplits = state.getPreserveSplits();
  if (state.getRegionInfoCount() == 0) {
    regions = null;
  } else {
    regions = new ArrayList<HRegionInfo>(state.getRegionInfoCount());
    for (HBaseProtos.RegionInfo hri: state.getRegionInfoList()) {
      regions.add(HRegionInfo.convert(hri));
    }
  }
}
 

import org.apache.hadoop.hbase.HRegionInfo; //導入依賴的package包/類
@Test(timeout=60000)
public void testCreateTwiceWithSameNonce() throws Exception {
  final TableName tableName = TableName.valueOf("testCreateTwiceWithSameNonce");
  final ProcedureExecutor<MasterProcedureEnv> procExec = getMasterProcedureExecutor();
  final HTableDescriptor htd = MasterProcedureTestingUtility.createHTD(tableName, "f");
  final HRegionInfo[] regions = ModifyRegionUtils.createHRegionInfos(htd, null);

  // create the table
  long procId1 = procExec.submitProcedure(
    new CreateTableProcedure(procExec.getEnvironment(), htd, regions), nonceGroup, nonce);

  // create another with the same name
  long procId2 = procExec.submitProcedure(
    new CreateTableProcedure(procExec.getEnvironment(), htd, regions), nonceGroup, nonce);

  ProcedureTestingUtility.waitProcedure(procExec, procId1);
  ProcedureTestingUtility.assertProcNotFailed(procExec.getResult(procId1));

  ProcedureTestingUtility.waitProcedure(procExec, procId2);
  ProcedureTestingUtility.assertProcNotFailed(procExec.getResult(procId2));
  assertTrue(procId1 == procId2);
}
 

import org.apache.hadoop.hbase.HRegionInfo; //導入依賴的package包/類
/**
 * If merged region no longer holds reference to the merge regions, archive
 * merge region on hdfs and perform deleting references in hbase:meta
 * @param mergedRegion
 * @param regionA
 * @param regionB
 * @return true if we delete references in merged region on hbase:meta and archive
 *         the files on the file system
 * @throws IOException
 */
boolean cleanMergeRegion(final HRegionInfo mergedRegion,
    final HRegionInfo regionA, final HRegionInfo regionB) throws IOException {
  FileSystem fs = this.services.getMasterFileSystem().getFileSystem();
  Path rootdir = this.services.getMasterFileSystem().getRootDir();
  Path tabledir = FSUtils.getTableDir(rootdir, mergedRegion.getTable());
  HTableDescriptor htd = getTableDescriptor(mergedRegion.getTable());
  HRegionFileSystem regionFs = null;
  try {
    regionFs = HRegionFileSystem.openRegionFromFileSystem(
        this.services.getConfiguration(), fs, tabledir, mergedRegion, true);
  } catch (IOException e) {
    LOG.warn("Merged region does not exist: " + mergedRegion.getEncodedName());
  }
  if (regionFs == null || !regionFs.hasReferences(htd)) {
    LOG.debug("Deleting region " + regionA.getRegionNameAsString() + " and "
        + regionB.getRegionNameAsString()
        + " from fs because merged region no longer holds references");
    HFileArchiver.archiveRegion(this.services.getConfiguration(), fs, regionA);
    HFileArchiver.archiveRegion(this.services.getConfiguration(), fs, regionB);
    MetaTableAccessor.deleteMergeQualifiers(server.getConnection(),
      mergedRegion);
    return true;
  }
  return false;
}
 

import org.apache.hadoop.hbase.HRegionInfo; //導入依賴的package包/類
public OpenedRegionHandler(Server server,
    AssignmentManager assignmentManager, HRegionInfo regionInfo,
    OpenRegionCoordination coordination,
    OpenRegionCoordination.OpenRegionDetails ord) {
  super(server, EventType.RS_ZK_REGION_OPENED);
  this.assignmentManager = assignmentManager;
  this.regionInfo = regionInfo;
  this.coordination = coordination;
  this.ord = ord;
  if(regionInfo.isMetaRegion()) {
    priority = OpenedPriority.META;
  } else if(regionInfo.getTable()
      .getNamespaceAsString().equals(NamespaceDescriptor.SYSTEM_NAMESPACE_NAME_STR)) {
    priority = OpenedPriority.SYSTEM;
  } else {
    priority = OpenedPriority.USER;
  }
}
 

import org.apache.hadoop.hbase.HRegionInfo; //導入依賴的package包/類
@Override public WAL getWAL(HRegionInfo regionInfo) throws IOException {
  WAL wal;
  LogRoller roller = walRoller;
  //_ROOT_ and hbase:meta regions have separate WAL.
  if (regionInfo != null && regionInfo.isMetaTable()
      && regionInfo.getReplicaId() == HRegionInfo.DEFAULT_REPLICA_ID) {
    roller = ensureMetaWALRoller();
    wal = walFactory.getMetaWAL(regionInfo.getEncodedNameAsBytes());
  } else if (regionInfo == null) {
    wal = walFactory.getWAL(UNSPECIFIED_REGION);
  } else {
    wal = walFactory.getWAL(regionInfo.getEncodedNameAsBytes());
  }
  roller.addWAL(wal);
  return wal;
}
 

import org.apache.hadoop.hbase.HRegionInfo; //導入依賴的package包/類
private Result getMetaRow() throws IOException {
  Result currentRow = metaScanner.next();
  boolean foundResult = false;
  while (currentRow != null) {
    LOG.info("Row: <" + Bytes.toStringBinary(currentRow.getRow()) + ">");
    byte[] regionInfoValue = currentRow.getValue(HConstants.CATALOG_FAMILY,
        HConstants.REGIONINFO_QUALIFIER);
    if (regionInfoValue == null || regionInfoValue.length == 0) {
      currentRow = metaScanner.next();
      continue;
    }
    HRegionInfo region = HRegionInfo.getHRegionInfo(currentRow);
    if (!region.getTable().equals(this.tableName)) {
      currentRow = metaScanner.next();
      continue;
    }
    foundResult = true;
    break;
  }
  return foundResult ? currentRow : null;
}
 

import org.apache.hadoop.hbase.HRegionInfo; //導入依賴的package包/類
@Override
public void deserializeStateData(final InputStream stream) throws IOException {
  super.deserializeStateData(stream);

  MasterProcedureProtos.CreateTableStateData state =
    MasterProcedureProtos.CreateTableStateData.parseDelimitedFrom(stream);
  user = MasterProcedureUtil.toUserInfo(state.getUserInfo());
  hTableDescriptor = HTableDescriptor.convert(state.getTableSchema());
  if (state.getRegionInfoCount() == 0) {
    newRegions = null;
  } else {
    newRegions = new ArrayList<HRegionInfo>(state.getRegionInfoCount());
    for (HBaseProtos.RegionInfo hri: state.getRegionInfoList()) {
      newRegions.add(HRegionInfo.convert(hri));
    }
  }
}