Java HRegionInfo.getRegionNameAsString方法代碼示例

import org.apache.hadoop.hbase.HRegionInfo; //導入方法依賴的package包/類
public void deleteFamilyFromFS(HRegionInfo region, byte[] familyName)
    throws IOException {
  // archive family store files
  Path tableDir = FSUtils.getTableDir(rootdir, region.getTable());
  HFileArchiver.archiveFamily(fs, conf, region, tableDir, familyName);

  // delete the family folder
  Path familyDir = new Path(tableDir,
    new Path(region.getEncodedName(), Bytes.toString(familyName)));
  if (fs.delete(familyDir, true) == false) {
    if (fs.exists(familyDir)) {
      throw new IOException("Could not delete family "
          + Bytes.toString(familyName) + " from FileSystem for region "
          + region.getRegionNameAsString() + "(" + region.getEncodedName()
          + ")");
    }
  }
}
 

import org.apache.hadoop.hbase.HRegionInfo; //導入方法依賴的package包/類
/**
 * Sends an MERGE REGIONS RPC to the specified server to merge the specified
 * regions.
 * <p>
 * A region server could reject the close request because it either does not
 * have the specified region.
 * @param server server to merge regions
 * @param region_a region to merge
 * @param region_b region to merge
 * @param forcible true if do a compulsory merge, otherwise we will only merge
 *          two adjacent regions
 * @throws IOException
 */
public void sendRegionsMerge(ServerName server, HRegionInfo region_a,
    HRegionInfo region_b, boolean forcible) throws IOException {
  if (server == null)
    throw new NullPointerException("Passed server is null");
  if (region_a == null || region_b == null)
    throw new NullPointerException("Passed region is null");
  AdminService.BlockingInterface admin = getRsAdmin(server);
  if (admin == null) {
    throw new IOException("Attempting to send MERGE REGIONS RPC to server "
        + server.toString() + " for region "
        + region_a.getRegionNameAsString() + ","
        + region_b.getRegionNameAsString()
        + " failed because no RPC connection found to this server");
  }
  PayloadCarryingRpcController controller = newRpcController();
  ProtobufUtil.mergeRegions(controller, admin, region_a, region_b, forcible);
}
 

import org.apache.hadoop.hbase.HRegionInfo; //導入方法依賴的package包/類
/**
 * Archive the store file
 * @param fs the filesystem where the store files live
 * @param regionInfo region hosting the store files
 * @param conf {@link Configuration} to examine to determine the archive directory
 * @param tableDir {@link Path} to where the table is being stored (for building the archive path)
 * @param family the family hosting the store files
 * @param storeFile file to be archived
 * @throws IOException if the files could not be correctly disposed.
 */
public static void archiveStoreFile(Configuration conf, FileSystem fs, HRegionInfo regionInfo,
    Path tableDir, byte[] family, Path storeFile) throws IOException {
  Path storeArchiveDir = HFileArchiveUtil.getStoreArchivePath(conf, regionInfo, tableDir, family);
  // make sure we don't archive if we can't and that the archive dir exists
  if (!fs.mkdirs(storeArchiveDir)) {
    throw new IOException("Could not make archive directory (" + storeArchiveDir + ") for store:"
        + Bytes.toString(family) + ", deleting compacted files instead.");
  }

  // do the actual archive
  long start = EnvironmentEdgeManager.currentTime();
  File file = new FileablePath(fs, storeFile);
  if (!resolveAndArchiveFile(storeArchiveDir, file, Long.toString(start))) {
    throw new IOException("Failed to archive/delete the file for region:"
        + regionInfo.getRegionNameAsString() + ", family:" + Bytes.toString(family)
        + " into " + storeArchiveDir + ". Something is probably awry on the filesystem.");
  }
}
 

import org.apache.hadoop.hbase.HRegionInfo; //導入方法依賴的package包/類
/**
 * @param r Region we're working on.
 * @return whether znode is successfully transitioned to OPENED state.
 * @throws java.io.IOException
 */
@Override
public boolean transitionToOpened(final HRegion r, OpenRegionDetails ord) throws IOException {
  ZkOpenRegionDetails zkOrd = (ZkOpenRegionDetails) ord;

  boolean result = false;
  HRegionInfo hri = r.getRegionInfo();
  final String name = hri.getRegionNameAsString();
  // Finally, Transition ZK node to OPENED
  try {
    if (ZKAssign.transitionNodeOpened(watcher, hri,
      zkOrd.getServerName(), zkOrd.getVersion()) == -1) {
      String warnMsg = "Completed the OPEN of region " + name +
        " but when transitioning from " + " OPENING to OPENED ";
      try {
        String node = ZKAssign.getNodeName(watcher, hri.getEncodedName());
        if (ZKUtil.checkExists(watcher, node) < 0) {
          // if the znode
          coordination.getServer().abort(warnMsg + "the znode disappeared", null);
        } else {
          LOG.warn(warnMsg + "got a version mismatch, someone else clashed; " +
            "so now unassigning -- closing region on server: " + zkOrd.getServerName());
        }
      } catch (KeeperException ke) {
        coordination.getServer().abort(warnMsg, ke);
      }
    } else {
      LOG.debug("Transitioned " + r.getRegionInfo().getEncodedName() +
        " to OPENED in zk on " + zkOrd.getServerName());
      result = true;
    }
  } catch (KeeperException e) {
    LOG.error("Failed transitioning node " + name +
      " from OPENING to OPENED -- closing region", e);
  }
  return result;
}
 

import org.apache.hadoop.hbase.HRegionInfo; //導入方法依賴的package包/類
/**
 * Try to transition to open.
 *
 * This is not guaranteed to succeed, we just do our best.
 *
 * @param rsServices
 * @param hri Region we're working on.
 * @param ord Details about region open task
 * @return whether znode is successfully transitioned to FAILED_OPEN state.
 */
@Override
public boolean tryTransitionFromOfflineToFailedOpen(RegionServerServices rsServices,
                                                    final HRegionInfo hri,
                                                    OpenRegionDetails ord) {
  ZkOpenRegionDetails zkOrd = (ZkOpenRegionDetails) ord;
  boolean result = false;
  final String name = hri.getRegionNameAsString();
  try {
    LOG.info("Opening of region " + hri + " failed, transitioning" +
      " from OFFLINE to FAILED_OPEN in ZK, expecting version " +
      zkOrd.getVersionOfOfflineNode());
    if (ZKAssign.transitionNode(
      rsServices.getZooKeeper(), hri,
      rsServices.getServerName(),
      EventType.M_ZK_REGION_OFFLINE,
      EventType.RS_ZK_REGION_FAILED_OPEN,
      zkOrd.getVersionOfOfflineNode()) == -1) {
      LOG.warn("Unable to mark region " + hri + " as FAILED_OPEN. " +
        "It's likely that the master already timed out this open " +
        "attempt, and thus another RS already has the region.");
    } else {
      result = true;
    }
  } catch (KeeperException e) {
    LOG.error("Failed transitioning node " + name + " from OFFLINE to FAILED_OPEN", e);
  }
  return result;
}
 

import org.apache.hadoop.hbase.HRegionInfo; //導入方法依賴的package包/類
/**
 * This is not guaranteed to succeed, we just do our best.
 * @param hri Region we're working on.
 * @return whether znode is successfully transitioned to FAILED_OPEN state.
 */
@Override
public boolean tryTransitionFromOpeningToFailedOpen(final HRegionInfo hri,
                                                    OpenRegionDetails ord) {
  ZkOpenRegionDetails zkOrd = (ZkOpenRegionDetails) ord;
  boolean result = false;
  final String name = hri.getRegionNameAsString();
  try {
    LOG.info("Opening of region " + hri + " failed, transitioning" +
      " from OPENING to FAILED_OPEN in ZK, expecting version " + zkOrd.getVersion());
    if (ZKAssign.transitionNode(
      watcher, hri,
      zkOrd.getServerName(),
      EventType.RS_ZK_REGION_OPENING,
      EventType.RS_ZK_REGION_FAILED_OPEN,
      zkOrd.getVersion()) == -1) {
      LOG.warn("Unable to mark region " + hri + " as FAILED_OPEN. " +
        "It's likely that the master already timed out this open " +
        "attempt, and thus another RS already has the region.");
    } else {
      result = true;
    }
  } catch (KeeperException e) {
    LOG.error("Failed transitioning node " + name +
      " from OPENING to FAILED_OPEN", e);
  }
  return result;
}
 

import org.apache.hadoop.hbase.HRegionInfo; //導入方法依賴的package包/類
/**
 * Sends an CLOSE RPC to the specified server to close the specified region.
 * <p>
 * A region server could reject the close request because it either does not
 * have the specified region or the region is being split.
 * @param server server to open a region
 * @param region region to open
 * @param versionOfClosingNode
 *   the version of znode to compare when RS transitions the znode from
 *   CLOSING state.
 * @param dest - if the region is moved to another server, the destination server. null otherwise.
 * @return true if server acknowledged close, false if not
 * @throws IOException
 */
public boolean sendRegionClose(ServerName server, HRegionInfo region,
  int versionOfClosingNode, ServerName dest, boolean transitionInZK) throws IOException {
  if (server == null) throw new NullPointerException("Passed server is null");
  AdminService.BlockingInterface admin = getRsAdmin(server);
  if (admin == null) {
    throw new IOException("Attempting to send CLOSE RPC to server " +
      server.toString() + " for region " +
      region.getRegionNameAsString() +
      " failed because no RPC connection found to this server");
  }
  PayloadCarryingRpcController controller = newRpcController();
  return ProtobufUtil.closeRegion(controller, admin, server, region.getRegionName(),
    versionOfClosingNode, dest, transitionInZK);
}
 

import org.apache.hadoop.hbase.HRegionInfo; //導入方法依賴的package包/類
void checkTableInfo(TableInfoModel model) {
  assertEquals(model.getName(), TABLE.getNameAsString());
  Iterator<TableRegionModel> regions = model.getRegions().iterator();
  assertTrue(regions.hasNext());
  while (regions.hasNext()) {
    TableRegionModel region = regions.next();
    boolean found = false;
    for (HRegionLocation e: regionMap) {
      HRegionInfo hri = e.getRegionInfo();
      String hriRegionName = hri.getRegionNameAsString();
      String regionName = region.getName();
      if (hriRegionName.equals(regionName)) {
        found = true;
        byte[] startKey = hri.getStartKey();
        byte[] endKey = hri.getEndKey();
        ServerName serverName = e.getServerName();
        InetSocketAddress sa =
            new InetSocketAddress(serverName.getHostname(), serverName.getPort());
        String location = sa.getHostName() + ":" +
          Integer.valueOf(sa.getPort());
        assertEquals(hri.getRegionId(), region.getId());
        assertTrue(Bytes.equals(startKey, region.getStartKey()));
        assertTrue(Bytes.equals(endKey, region.getEndKey()));
        assertEquals(location, region.getLocation());
        break;
      }
    }
    assertTrue(found);
  }
}
 

import org.apache.hadoop.hbase.HRegionInfo; //導入方法依賴的package包/類
/**
 * Transitions an existing ephemeral node for the specified region which is currently in the begin
 * state to be in the end state. Master cleans up the final SPLIT znode when it reads it (or if we
 * crash, zk will clean it up).
 * <p>
 * Does not transition nodes from other states. If for some reason the node could not be
 * transitioned, the method returns -1. If the transition is successful, the version of the node
 * after transition is returned.
 * <p>
 * This method can fail and return false for three different reasons:
 * <ul>
 * <li>Node for this region does not exist</li>
 * <li>Node for this region is not in the begin state</li>
 * <li>After verifying the begin state, update fails because of wrong version (this should never
 * actually happen since an RS only does this transition following a transition to the begin
 * state. If two RS are conflicting, one would fail the original transition to the begin state and
 * not this transition)</li>
 * </ul>
 * <p>
 * Does not set any watches.
 * <p>
 * This method should only be used by a RegionServer when splitting a region.
 * @param parent region to be transitioned to opened
 * @param a Daughter a of split
 * @param b Daughter b of split
 * @param serverName server event originates from
 * @param std split transaction details
 * @param beginState the expected current state the znode should be
 * @param endState the state to be transition to
 * @return version of node after transition, -1 if unsuccessful transition
 * @throws IOException
 */

private int transitionSplittingNode(HRegionInfo parent, HRegionInfo a, HRegionInfo b,
    ServerName serverName, SplitTransactionDetails std, final EventType beginState,
    final EventType endState) throws IOException {
  ZkSplitTransactionDetails zstd = (ZkSplitTransactionDetails) std;
  byte[] payload = HRegionInfo.toDelimitedByteArray(a, b);
  try {
    return ZKAssign.transitionNode(watcher, parent, serverName, beginState, endState,
      zstd.getZnodeVersion(), payload);
  } catch (KeeperException e) {
    throw new IOException(
        "Failed transition of splitting node " + parent.getRegionNameAsString(), e);
  }
}