Java ZKAssign.getNodeName方法代码示例

import org.apache.hadoop.hbase.zookeeper.ZKAssign; //导入方法依赖的package包/类
/**
 * Creates a new ephemeral node in the PENDING_SPLIT state for the specified region. Create it
 * ephemeral in case regionserver dies mid-split.
 * <p>
 * Does not transition nodes from other states. If a node already exists for this region, an
 * Exception will be thrown.
 * @param parent region to be created as offline
 * @param serverName server event originates from
 * @param hri_a daughter region
 * @param hri_b daughter region
 * @throws IOException
 */

@Override
public void startSplitTransaction(HRegion parent, ServerName serverName, HRegionInfo hri_a,
    HRegionInfo hri_b) throws IOException {

  HRegionInfo region = parent.getRegionInfo();
  try {

    LOG.debug(watcher.prefix("Creating ephemeral node for " + region.getEncodedName()
        + " in PENDING_SPLIT state"));
    byte[] payload = HRegionInfo.toDelimitedByteArray(hri_a, hri_b);
    RegionTransition rt =
        RegionTransition.createRegionTransition(RS_ZK_REQUEST_REGION_SPLIT,
          region.getRegionName(), serverName, payload);
    String node = ZKAssign.getNodeName(watcher, region.getEncodedName());
    if (!ZKUtil.createEphemeralNodeAndWatch(watcher, node, rt.toByteArray())) {
      throw new IOException("Failed create of ephemeral " + node);
    }

  } catch (KeeperException e) {
    throw new IOException("Failed creating PENDING_SPLIT znode on "
        + parent.getRegionInfo().getRegionNameAsString(), e);
  }

}
 

import org.apache.hadoop.hbase.zookeeper.ZKAssign; //导入方法依赖的package包/类
/**
 * Creates a new ephemeral node in the PENDING_MERGE state for the merged region.
 * Create it ephemeral in case regionserver dies mid-merge.
 *
 * <p>
 * Does not transition nodes from other states. If a node already exists for
 * this region, a {@link org.apache.zookeeper.KeeperException.NodeExistsException} will be thrown.
 *
 * @param region region to be created as offline
 * @param serverName server event originates from
 * @throws IOException
 */
@Override
public void startRegionMergeTransaction(final HRegionInfo region, final ServerName serverName,
    final HRegionInfo a, final HRegionInfo b) throws IOException {
  LOG.debug(watcher.prefix("Creating ephemeral node for " + region.getEncodedName()
      + " in PENDING_MERGE state"));
  byte[] payload = HRegionInfo.toDelimitedByteArray(region, a, b);
  RegionTransition rt =
      RegionTransition.createRegionTransition(RS_ZK_REQUEST_REGION_MERGE, region.getRegionName(),
        serverName, payload);
  String node = ZKAssign.getNodeName(watcher, region.getEncodedName());
  try {
    if (!ZKUtil.createEphemeralNodeAndWatch(watcher, node, rt.toByteArray())) {
      throw new IOException("Failed create of ephemeral " + node);
    }
  } catch (KeeperException e) {
    throw new IOException(e);
  }
}
 

import org.apache.hadoop.hbase.zookeeper.ZKAssign; //导入方法依赖的package包/类
/**
 * Verifies that the specified region is in the specified state in ZooKeeper.
 * <p>
 * Returns true if region is in transition and in the specified state in
 * ZooKeeper.  Returns false if the region does not exist in ZK or is in
 * a different state.
 * <p>
 * Method synchronizes() with ZK so will yield an up-to-date result but is
 * a slow read.
 * @param zkw
 * @param region
 * @param expectedState
 * @return true if region exists and is in expected state
 * @throws DeserializationException
 */
static boolean verifyRegionState(ZooKeeperWatcher zkw, HRegionInfo region, EventType expectedState)
throws KeeperException, DeserializationException {
  String encoded = region.getEncodedName();

  String node = ZKAssign.getNodeName(zkw, encoded);
  zkw.sync(node);

  // Read existing data of the node
  byte [] existingBytes = null;
  try {
    existingBytes = ZKUtil.getDataAndWatch(zkw, node);
  } catch (KeeperException.NoNodeException nne) {
    return false;
  } catch (KeeperException e) {
    throw e;
  }
  if (existingBytes == null) return false;
  RegionTransition rt = RegionTransition.parseFrom(existingBytes);
  return rt.getEventType().equals(expectedState);
}
 

import org.apache.hadoop.hbase.zookeeper.ZKAssign; //导入方法依赖的package包/类
/**
 * Creates a new ephemeral node in the SPLITTING state for the specified region.
 * Create it ephemeral in case regionserver dies mid-split.
 *
 * <p>Does not transition nodes from other states.  If a node already exists
 * for this region, a {@link NodeExistsException} will be thrown.
 *
 * @param zkw zk reference
 * @param region region to be created as offline
 * @param serverName server event originates from
 * @return Version of znode created.
 * @throws KeeperException
 * @throws IOException
 */
// Copied from SplitTransaction rather than open the method over there in
// the regionserver package.
private static int createNodeSplitting(final ZooKeeperWatcher zkw,
    final HRegionInfo region, final ServerName serverName)
throws KeeperException, IOException {
  RegionTransitionData data =
    new RegionTransitionData(EventType.RS_ZK_REGION_SPLITTING,
      region.getRegionName(), serverName);

  String node = ZKAssign.getNodeName(zkw, region.getEncodedName());
  if (!ZKUtil.createEphemeralNodeAndWatch(zkw, node, data.getBytes())) {
    throw new IOException("Failed create of ephemeral " + node);
  }
  // Transition node from SPLITTING to SPLITTING and pick up version so we
  // can be sure this znode is ours; version is needed deleting.
  return transitionNodeSplitting(zkw, region, serverName, -1);
}
 

import org.apache.hadoop.hbase.zookeeper.ZKAssign; //导入方法依赖的package包/类
/**
 * Creates a new ephemeral node in the SPLITTING state for the specified region.
 * Create it ephemeral in case regionserver dies mid-split.
 *
 * <p>Does not transition nodes from other states.  If a node already exists
 * for this region, a {@link NodeExistsException} will be thrown.
 *
 * @param zkw zk reference
 * @param region region to be created as offline
 * @param serverName server event originates from
 * @return Version of znode created.
 * @throws KeeperException
 * @throws IOException
 */
// Copied from SplitTransaction rather than open the method over there in
// the regionserver package.
private static int createNodeSplitting(final ZooKeeperWatcher zkw,
    final HRegionInfo region, final ServerName serverName)
throws KeeperException, IOException {
  RegionTransition rt =
    RegionTransition.createRegionTransition(EventType.RS_ZK_REGION_SPLITTING,
      region.getRegionName(), serverName);

  String node = ZKAssign.getNodeName(zkw, region.getEncodedName());
  if (!ZKUtil.createEphemeralNodeAndWatch(zkw, node, rt.toByteArray())) {
    throw new IOException("Failed create of ephemeral " + node);
  }
  // Transition node from SPLITTING to SPLITTING and pick up version so we
  // can be sure this znode is ours; version is needed deleting.
  return transitionNodeSplitting(zkw, region, serverName, -1);
}
 

import org.apache.hadoop.hbase.zookeeper.ZKAssign; //导入方法依赖的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.zookeeper.ZKAssign; //导入方法依赖的package包/类
private void processAlreadyOpenedRegion(HRegionInfo region, ServerName sn) {
  // Remove region from in-memory transition and unassigned node from ZK
  // While trying to enable the table the regions of the table were
  // already enabled.
  LOG.debug("ALREADY_OPENED " + region.getRegionNameAsString()
    + " to " + sn);
  String encodedName = region.getEncodedName();
  
  //If use ZkForAssignment, region already Opened event should not be handled, 
  //leave it to zk event. See HBase-14407.
  if(useZKForAssignment){
    String node = ZKAssign.getNodeName(watcher, encodedName);
    Stat stat = new Stat();
    try {
      byte[] existingBytes = ZKUtil.getDataNoWatch(watcher, node, stat);
      if(existingBytes!=null){
        RegionTransition rt= RegionTransition.parseFrom(existingBytes);
        EventType et = rt.getEventType();
        if (et.equals(EventType.RS_ZK_REGION_OPENED)) {
          LOG.debug("ALREADY_OPENED " + region.getRegionNameAsString()
            + " and node in "+et+" state");
          return;
        }
      }
    } catch (KeeperException ke) {
      LOG.warn("Unexpected ZK exception getData " + node
        + " node for the region " + encodedName, ke);
    } catch (DeserializationException e) {
      LOG.warn("Get RegionTransition from zk deserialization failed! ", e);
    }
    
    deleteNodeInStates(encodedName, "offline", sn, EventType.M_ZK_REGION_OFFLINE);
  }
  
  regionStates.regionOnline(region, sn);
}
 

import org.apache.hadoop.hbase.zookeeper.ZKAssign; //导入方法依赖的package包/类
void fixupDaughters(final MonitoredTask status) throws IOException, KeeperException {
  final Map<HRegionInfo, Result> offlineSplitParents =
    new HashMap<HRegionInfo, Result>();
  // This visitor collects offline split parents in the .META. table
  MetaReader.Visitor visitor = new MetaReader.Visitor() {
    @Override
    public boolean visit(Result r) throws IOException {
      if (r == null || r.isEmpty()) return true;
      HRegionInfo info =
        MetaReader.parseHRegionInfoFromCatalogResult(
          r, HConstants.REGIONINFO_QUALIFIER);
      if (info == null) return true; // Keep scanning
      if (info.isOffline() && info.isSplit()) {
        offlineSplitParents.put(info, r);
      }
      // Returning true means "keep scanning"
      return true;
    }
  };
  // Run full scan of .META. catalog table passing in our custom visitor
  MetaReader.fullScan(this.catalogTracker, visitor);
  // Now work on our list of found parents. See if any we can clean up.
  int fixups = 0;
  for (Map.Entry<HRegionInfo, Result> e : offlineSplitParents.entrySet()) {
    String node = ZKAssign.getNodeName(zooKeeper, e.getKey().getEncodedName());
    byte[] data = ZKUtil.getData(zooKeeper, node);
    if (data == null) { // otherwise, splitting is still going on, skip it
      fixups += ServerShutdownHandler.fixupDaughters(
        e.getValue(), assignmentManager, catalogTracker);
    }
  }
  if (fixups != 0) {
    LOG.info("Scanned the catalog and fixed up " + fixups +
      " missing daughter region(s)");
  }
}
 

import org.apache.hadoop.hbase.zookeeper.ZKAssign; //导入方法依赖的package包/类
@Test(timeout = 60000)
public void testTableExistsIfTheSpecifiedTableRegionIsSplitParent() throws Exception {
  ZooKeeperWatcher zkw = HBaseTestingUtility.getZooKeeperWatcher(TESTING_UTIL);
  final byte[] tableName = 
      Bytes.toBytes("testTableExistsIfTheSpecifiedTableRegionIsSplitParent");
  HRegionServer regionServer = null;
  List<HRegion> regions = null;
  HBaseAdmin admin = new HBaseAdmin(TESTING_UTIL.getConfiguration());
  try {
    // Create table then get the single region for our new table.
    HTable t = createTableAndWait(tableName, Bytes.toBytes("cf"));
    regions = cluster.getRegions(tableName);
    int regionServerIndex = cluster.getServerWith(regions.get(0).getRegionName());
    regionServer = cluster.getRegionServer(regionServerIndex);
    insertData(tableName, admin, t);
    // Turn off balancer so it doesn't cut in and mess up our placements.
    cluster.getMaster().setCatalogJanitorEnabled(false);
    boolean tableExists = MetaReader.tableExists(regionServer.getCatalogTracker(),
        Bytes.toString(tableName));
    assertEquals("The specified table should present.", true, tableExists);
    SplitTransaction st = new SplitTransaction(regions.get(0), Bytes.toBytes("row2"));
    try {
      st.prepare();
      st.createDaughters(regionServer, regionServer);
    } catch (IOException e) {

    }
    tableExists = MetaReader.tableExists(regionServer.getCatalogTracker(),
        Bytes.toString(tableName));
    assertEquals("The specified table should present.", true, tableExists);
  } finally {
    if (regions != null) {
      String node = ZKAssign.getNodeName(zkw, regions.get(0).getRegionInfo()
          .getEncodedName());
      ZKUtil.deleteNodeFailSilent(zkw, node);
    }
    cluster.getMaster().setCatalogJanitorEnabled(true);
    admin.close();
  }
}
 

import org.apache.hadoop.hbase.zookeeper.ZKAssign; //导入方法依赖的package包/类
/**
 * @param r Region we're working on.
 * @return whether znode is successfully transitioned to OPENED state.
 * @throws IOException
 */
boolean transitionToOpened(final HRegion r) throws IOException {
  boolean result = false;
  HRegionInfo hri = r.getRegionInfo();
  final String name = hri.getRegionNameAsString();
  // Finally, Transition ZK node to OPENED
  try {
    if (ZKAssign.transitionNodeOpened(this.server.getZooKeeper(), hri,
        this.server.getServerName(), this.version) == -1) {
      String warnMsg = "Completed the OPEN of region " + name +
        " but when transitioning from " + " OPENING to OPENED ";
      try {
        String node = ZKAssign.getNodeName(this.server.getZooKeeper(), hri.getEncodedName());
        if (ZKUtil.checkExists(this.server.getZooKeeper(), node) < 0) {
          // if the znode 
          rsServices.abort(warnMsg + "the znode disappeared", null);
        } else {
          LOG.warn(warnMsg + "got a version mismatch, someone else clashed; " +
        "so now unassigning -- closing region on server: " + this.server.getServerName());
        }
      } catch (KeeperException ke) {
        rsServices.abort(warnMsg, ke);
      }
    } else {
      LOG.debug("Transitioned " + r.getRegionInfo().getEncodedName() +
        " to OPENED in zk on " + this.server.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.zookeeper.ZKAssign; //导入方法依赖的package包/类
@Test
public void testShouldNotCompeleteOpenedRegionSuccessfullyIfVersionMismatches()
    throws Exception {
  HRegion region = null;
  try {
    int testIndex = 0;
    TEST_UTIL.startMiniZKCluster();
    final Server server = new MockServer(TEST_UTIL);
    HTableDescriptor htd = new HTableDescriptor(
        TableName.valueOf("testShouldNotCompeleteOpenedRegionSuccessfullyIfVersionMismatches"));
    HRegionInfo hri = new HRegionInfo(htd.getTableName(),
        Bytes.toBytes(testIndex), Bytes.toBytes(testIndex + 1));
    region = HRegion.createHRegion(hri, TEST_UTIL.getDataTestDir(), TEST_UTIL.getConfiguration(), htd);
    assertNotNull(region);
    AssignmentManager am = Mockito.mock(AssignmentManager.class);
    RegionStates rsm = Mockito.mock(RegionStates.class);
    Mockito.doReturn(rsm).when(am).getRegionStates();
    when(rsm.isRegionInTransition(hri)).thenReturn(false);
    when(rsm.getRegionState(hri)).thenReturn(
      new RegionState(region.getRegionInfo(), RegionState.State.OPEN,
        System.currentTimeMillis(), server.getServerName()));
    // create a node with OPENED state
    zkw = HBaseTestingUtility.createAndForceNodeToOpenedState(TEST_UTIL,
        region, server.getServerName());
    when(am.getTableStateManager()).thenReturn(new ZKTableStateManager(zkw));
    Stat stat = new Stat();
    String nodeName = ZKAssign.getNodeName(zkw, region.getRegionInfo()
        .getEncodedName());
    ZKUtil.getDataAndWatch(zkw, nodeName, stat);

    // use the version for the OpenedRegionHandler
    BaseCoordinatedStateManager csm = new ZkCoordinatedStateManager();
    csm.initialize(server);
    csm.start();

    OpenRegionCoordination orc = csm.getOpenRegionCoordination();
    ZkOpenRegionCoordination.ZkOpenRegionDetails zkOrd =
      new ZkOpenRegionCoordination.ZkOpenRegionDetails();
    zkOrd.setServerName(server.getServerName());
    zkOrd.setVersion(stat.getVersion());
    OpenedRegionHandler handler = new OpenedRegionHandler(server, am, region
        .getRegionInfo(), orc, zkOrd);
    // Once again overwrite the same znode so that the version changes.
    ZKAssign.transitionNode(zkw, region.getRegionInfo(), server
        .getServerName(), EventType.RS_ZK_REGION_OPENED,
        EventType.RS_ZK_REGION_OPENED, stat.getVersion());

    // Should not invoke assignmentmanager.regionOnline. If it is 
    // invoked as per current mocking it will throw null pointer exception.
    boolean expectedException = false;
    try {
      handler.process();
    } catch (Exception e) {
      expectedException = true;
    }
    assertFalse("The process method should not throw any exception.",
        expectedException);
    List<String> znodes = ZKUtil.listChildrenAndWatchForNewChildren(zkw,
        zkw.assignmentZNode);
    String regionName = znodes.get(0);
    assertEquals("The region should not be opened successfully.", regionName,
        region.getRegionInfo().getEncodedName());
  } finally {
    HRegion.closeHRegion(region);
    TEST_UTIL.shutdownMiniZKCluster();
  }
}
 

import org.apache.hadoop.hbase.zookeeper.ZKAssign; //导入方法依赖的package包/类
/**
 * Test the openregionhandler can deal with perceived failure of transitioning to OPENED state
 * due to intermittent zookeeper malfunctioning.
 * @see <a href="https://issues.apache.org/jira/browse/HBASE-9387">HBASE-9387</a>
 * @throws IOException
 * @throws NodeExistsException
 * @throws KeeperException
 */
@Test
public void testRegionServerAbortionDueToFailureTransitioningToOpened()
    throws IOException, NodeExistsException, KeeperException {
  final Server server = new MockServer(HTU);
  final RegionServerServices rss = HTU.createMockRegionServerService();

  HTableDescriptor htd = TEST_HTD;
  final HRegionInfo hri = TEST_HRI;
  HRegion region =
       HRegion.createHRegion(hri, HTU.getDataTestDir(), HTU
          .getConfiguration(), htd);
  assertNotNull(region);
  try {

    ZkCoordinatedStateManager csm = new ZkCoordinatedStateManager();
    csm.initialize(server);
    csm.start();

    ZkOpenRegionCoordination.ZkOpenRegionDetails zkCrd =
      new ZkOpenRegionCoordination.ZkOpenRegionDetails();
    zkCrd.setServerName(server.getServerName());

    ZkOpenRegionCoordination openRegionCoordination =
      new ZkOpenRegionCoordination(csm, server.getZooKeeper()) {
      @Override
      public boolean transitionToOpened(final HRegion r, OpenRegionDetails ord)
          throws IOException {
        // remove znode simulating intermittent zookeeper connection issue
        ZooKeeperWatcher zkw = server.getZooKeeper();
        String node = ZKAssign.getNodeName(zkw, hri.getEncodedName());
        try {
          ZKUtil.deleteNodeFailSilent(zkw, node);
        } catch (KeeperException e) {
          throw new RuntimeException("Ugh failed delete of " + node, e);
        }
        // then try to transition to OPENED
        return super.transitionToOpened(r, ord);
      }
    };

    OpenRegionHandler handler = new OpenRegionHandler(server, rss, hri, htd,
      -1, openRegionCoordination, zkCrd);
    rss.getRegionsInTransitionInRS().put(
      hri.getEncodedNameAsBytes(), Boolean.TRUE);
    // Call process without first creating OFFLINE region in zk, see if
    // exception or just quiet return (expected).
    handler.process();
    rss.getRegionsInTransitionInRS().put(
      hri.getEncodedNameAsBytes(), Boolean.TRUE);
    ZKAssign.createNodeOffline(server.getZooKeeper(), hri, server.getServerName());
    // Call process again but this time yank the zk znode out from under it
    // post OPENING; again will expect it to come back w/o NPE or exception.
    handler.process();
  } catch (IOException ioe) {
  } finally {
    HRegion.closeHRegion(region);
  }
  // Region server is expected to abort due to OpenRegionHandler perceiving transitioning
  // to OPENED as failed
  // This was corresponding to the second handler.process() call above.
  assertTrue("region server should have aborted", server.isAborted());
}
 

import org.apache.hadoop.hbase.zookeeper.ZKAssign; //导入方法依赖的package包/类
/**
 * Verifies HBASE-5806.  Here the case is that splitting is completed but before the
 * CJ could remove the parent region the master is killed and restarted.
 * @throws IOException
 * @throws InterruptedException
 * @throws NodeExistsException
 * @throws KeeperException
 */
@Test (timeout = 300000)
public void testMasterRestartAtRegionSplitPendingCatalogJanitor()
    throws IOException, InterruptedException, NodeExistsException,
    KeeperException, ServiceException {
  final TableName tableName = TableName
      .valueOf("testMasterRestartAtRegionSplitPendingCatalogJanitor");

  // Create table then get the single region for our new table.
  HTable t = createTableAndWait(tableName, HConstants.CATALOG_FAMILY);
  List<HRegion> regions = cluster.getRegions(tableName);
  HRegionInfo hri = getAndCheckSingleTableRegion(regions);

  int tableRegionIndex = ensureTableRegionNotOnSameServerAsMeta(admin, hri);

  // Turn off balancer so it doesn't cut in and mess up our placements.
  this.admin.setBalancerRunning(false, true);
  // Turn off the meta scanner so it don't remove parent on us.
  cluster.getMaster().setCatalogJanitorEnabled(false);
  ZooKeeperWatcher zkw = new ZooKeeperWatcher(t.getConfiguration(),
    "testMasterRestartAtRegionSplitPendingCatalogJanitor", new UselessTestAbortable());
  try {
    // Add a bit of load up into the table so splittable.
    TESTING_UTIL.loadTable(t, HConstants.CATALOG_FAMILY, false);
    // Get region pre-split.
    HRegionServer server = cluster.getRegionServer(tableRegionIndex);
    printOutRegions(server, "Initial regions: ");

    this.admin.split(hri.getRegionNameAsString());
    checkAndGetDaughters(tableName);
    // Assert the ephemeral node is up in zk.
    String path = ZKAssign.getNodeName(zkw, hri.getEncodedName());
    Stat stats = zkw.getRecoverableZooKeeper().exists(path, false);
    LOG.info("EPHEMERAL NODE BEFORE SERVER ABORT, path=" + path + ", stats="
        + stats);
    String node = ZKAssign.getNodeName(zkw, hri.getEncodedName());
    Stat stat = new Stat();
    byte[] data = ZKUtil.getDataNoWatch(zkw, node, stat);
    // ZKUtil.create
    for (int i=0; data != null && i<60; i++) {
      Thread.sleep(1000);
      data = ZKUtil.getDataNoWatch(zkw, node, stat);
    }
    assertNull("Waited too long for ZK node to be removed: "+node, data);

    MockMasterWithoutCatalogJanitor master = abortAndWaitForMaster();

    this.admin = new HBaseAdmin(TESTING_UTIL.getConfiguration());

    // Update the region to be offline and split, so that HRegionInfo#equals
    // returns true in checking rebuilt region states map.
    hri.setOffline(true);
    hri.setSplit(true);
    RegionStates regionStates = master.getAssignmentManager().getRegionStates();
    assertTrue("Split parent should be in SPLIT state",
      regionStates.isRegionInState(hri, State.SPLIT));
    ServerName regionServerOfRegion = regionStates.getRegionServerOfRegion(hri);
    assertTrue(regionServerOfRegion == null);
  } finally {
    this.admin.setBalancerRunning(true, false);
    cluster.getMaster().setCatalogJanitorEnabled(true);
    t.close();
    zkw.close();
  }
}
 

import org.apache.hadoop.hbase.zookeeper.ZKAssign; //导入方法依赖的package包/类
private void testSplitBeforeSettingSplittingInZKInternals() throws Exception {
  final TableName tableName = TableName.valueOf("testSplitBeforeSettingSplittingInZK");
  try {
    // Create table then get the single region for our new table.
    createTableAndWait(tableName, Bytes.toBytes("cf"));

    List<HRegion> regions = awaitTableRegions(tableName);
    assertTrue("Table not online", cluster.getRegions(tableName).size() != 0);

    int regionServerIndex = cluster.getServerWith(regions.get(0).getRegionInfo()
      .getRegionName());
    HRegionServer regionServer = cluster.getRegionServer(regionServerIndex);
    final HRegion region = findSplittableRegion(regions);
    assertTrue("not able to find a splittable region", region != null);
    SplitTransactionImpl st = new MockedSplitTransaction(region, Bytes.toBytes("row2")) {
      @Override
      public PairOfSameType<Region> stepsBeforePONR(final Server server,
          final RegionServerServices services, boolean testing) throws IOException {
        throw new SplittingNodeCreationFailedException ();
      }
    };
    String node = ZKAssign.getNodeName(regionServer.getZooKeeper(),
        region.getRegionInfo().getEncodedName());
    regionServer.getZooKeeper().sync(node);
    for (int i = 0; i < 100; i++) {
      // We expect the znode to be deleted by this time. Here the
      // znode could be in OPENED state and the
      // master has not yet deleted the znode.
      if (ZKUtil.checkExists(regionServer.getZooKeeper(), node) != -1) {
        Thread.sleep(100);
      }
    }
    try {
      st.prepare();
      st.execute(regionServer, regionServer);
    } catch (IOException e) {
      // check for the specific instance in case the Split failed due to the
      // existence of the znode in OPENED state.
      // This will at least make the test to fail;
      assertTrue("Should be instance of CreateSplittingNodeFailedException",
          e instanceof SplittingNodeCreationFailedException );
      node = ZKAssign.getNodeName(regionServer.getZooKeeper(),
          region.getRegionInfo().getEncodedName());
      {
        assertTrue(ZKUtil.checkExists(regionServer.getZooKeeper(), node) == -1);
      }
      assertTrue(st.rollback(regionServer, regionServer));
      assertTrue(ZKUtil.checkExists(regionServer.getZooKeeper(), node) == -1);
    }
  } finally {
    TESTING_UTIL.deleteTable(tableName);
  }
}
 

import org.apache.hadoop.hbase.zookeeper.ZKAssign; //导入方法依赖的package包/类
/**
 * Verifies HBASE-5806.  Here the case is that splitting is completed but before the
 * CJ could remove the parent region the master is killed and restarted.
 * @throws IOException
 * @throws InterruptedException
 * @throws NodeExistsException
 * @throws KeeperException
 */
@Test (timeout = 300000)
public void testMasterRestartAtRegionSplitPendingCatalogJanitor()
    throws IOException, InterruptedException, NodeExistsException,
    KeeperException, ServiceException {
  final byte[] tableName = Bytes.toBytes("testMasterRestartAtRegionSplitPendingCatalogJanitor");

  // Create table then get the single region for our new table.
  HTable t = createTableAndWait(tableName, HConstants.CATALOG_FAMILY);
  List<HRegion> regions = cluster.getRegions(tableName);
  HRegionInfo hri = getAndCheckSingleTableRegion(regions);

  int tableRegionIndex = ensureTableRegionNotOnSameServerAsMeta(admin, hri);

  // Turn off balancer so it doesn't cut in and mess up our placements.
  this.admin.setBalancerRunning(false, true);
  // Turn off the meta scanner so it don't remove parent on us.
  cluster.getMaster().setCatalogJanitorEnabled(false);
  ZooKeeperWatcher zkw = new ZooKeeperWatcher(t.getConfiguration(),
    "testMasterRestartAtRegionSplitPendingCatalogJanitor", new UselessTestAbortable());
  try {
    // Add a bit of load up into the table so splittable.
    TESTING_UTIL.loadTable(t, HConstants.CATALOG_FAMILY, false);
    // Get region pre-split.
    HRegionServer server = cluster.getRegionServer(tableRegionIndex);
    printOutRegions(server, "Initial regions: ");

    this.admin.split(hri.getRegionNameAsString());
    checkAndGetDaughters(tableName);
    // Assert the ephemeral node is up in zk.
    String path = ZKAssign.getNodeName(zkw, hri.getEncodedName());
    Stat stats = zkw.getRecoverableZooKeeper().exists(path, false);
    LOG.info("EPHEMERAL NODE BEFORE SERVER ABORT, path=" + path + ", stats="
        + stats);
    String node = ZKAssign.getNodeName(zkw, hri.getEncodedName());
    Stat stat = new Stat();
    byte[] data = ZKUtil.getDataNoWatch(zkw, node, stat);
    // ZKUtil.create
    for (int i=0; data != null && i<60; i++) {
      Thread.sleep(1000);
      data = ZKUtil.getDataNoWatch(zkw, node, stat);
    }
    assertNull("Waited too long for ZK node to be removed: "+node, data);

    MockMasterWithoutCatalogJanitor master = abortAndWaitForMaster();

    this.admin = new HBaseAdmin(TESTING_UTIL.getConfiguration());

    // Update the region to be offline and split, so that HRegionInfo#equals
    // returns true in checking rebuilt region states map.
    hri.setOffline(true);
    hri.setSplit(true);
    RegionStates regionStates = master.getAssignmentManager().getRegionStates();
    assertTrue("Split parent should be in SPLIT state",
      regionStates.isRegionInState(hri, State.SPLIT));
    ServerName regionServerOfRegion = regionStates.getRegionServerOfRegion(hri);
    assertTrue(regionServerOfRegion == null);
  } finally {
    this.admin.setBalancerRunning(true, false);
    cluster.getMaster().setCatalogJanitorEnabled(true);
    t.close();
    zkw.close();
  }
}