Java ZKAssign.transitionNodeOpened方法代码示例

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
 */
private 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) {
      LOG.warn("Completed the OPEN of region " + name +
        " but when transitioning from " +
        " OPENING to OPENED got a version mismatch, someone else clashed " +
        "so now unassigning -- closing region on server: " +
        this.server.getServerName());
    } else {
      LOG.debug("region transitioned to opened in zookeeper: " +
        r.getRegionInfo() + ", server: " + 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包/类
/**
 * Fakes the regionserver-side zk transitions of a region open.
 * @param w ZooKeeperWatcher to use.
 * @param sn Name of the regionserver doing the 'opening'
 * @param hri Region we're 'opening'.
 * @throws KeeperException
 * @throws DeserializationException
 */
static void fakeRegionServerRegionOpenInZK(HMaster master,  final ZooKeeperWatcher w,
    final ServerName sn, final HRegionInfo hri)
  throws KeeperException, DeserializationException, InterruptedException {
  // Wait till the we region is ready to be open in RIT.
  waitForRegionPendingOpenInRIT(master.getAssignmentManager(), hri.getEncodedName());

  // Get current versionid else will fail on transition from OFFLINE to OPENING below
  int versionid = ZKAssign.getVersion(w, hri);
  assertNotSame(-1, versionid);
  // This uglyness below is what the openregionhandler on RS side does.  I
  // looked at exposing the method over in openregionhandler but its just a
  // one liner and its deep over in another package so just repeat it below.
  versionid = ZKAssign.transitionNode(w, hri, sn,
    EventType.M_ZK_REGION_OFFLINE, EventType.RS_ZK_REGION_OPENING, versionid);
  assertNotSame(-1, versionid);
  // Move znode from OPENING to OPENED as RS does on successful open.
  versionid = ZKAssign.transitionNodeOpened(w, hri, sn, versionid);
  assertNotSame(-1, versionid);
  // We should be done now.  The master open handler will notice the
  // transition and remove this regions znode.
}
 

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 setRegionOpenedOnZK(final ZooKeeperWatcher zkWatcher, final ServerName serverName,
                                 HRegionInfo hregionInfo) throws Exception {
  int version = ZKAssign.getVersion(zkWatcher, hregionInfo);
  int versionTransition = ZKAssign.transitionNode(zkWatcher,
      hregionInfo, serverName, EventType.M_ZK_REGION_OFFLINE,
      EventType.RS_ZK_REGION_OPENING, version);
  ZKAssign.transitionNodeOpened(zkWatcher, hregionInfo, serverName, versionTransition);
}
 

import org.apache.hadoop.hbase.zookeeper.ZKAssign; //导入方法依赖的package包/类
/**
 * Creates a znode with OPENED state.
 * @param TEST_UTIL
 * @param region
 * @param serverName
 * @return
 * @throws IOException
 * @throws org.apache.hadoop.hbase.ZooKeeperConnectionException
 * @throws KeeperException
 * @throws NodeExistsException
 */
public static ZooKeeperWatcher createAndForceNodeToOpenedState(
    HBaseTestingUtility TEST_UTIL, HRegion region,
    ServerName serverName) throws ZooKeeperConnectionException,
    IOException, KeeperException, NodeExistsException {
  ZooKeeperWatcher zkw = getZooKeeperWatcher(TEST_UTIL);
  ZKAssign.createNodeOffline(zkw, region.getRegionInfo(), serverName);
  int version = ZKAssign.transitionNodeOpening(zkw, region
      .getRegionInfo(), serverName);
  ZKAssign.transitionNodeOpened(zkw, region.getRegionInfo(), serverName,
      version);
  return zkw;
}
 

import org.apache.hadoop.hbase.zookeeper.ZKAssign; //导入方法依赖的package包/类
/**
 * Creates a znode with OPENED state.
 * @param TEST_UTIL
 * @param region
 * @param serverName
 * @return
 * @throws IOException
 * @throws ZooKeeperConnectionException
 * @throws KeeperException
 * @throws NodeExistsException
 */
public static ZooKeeperWatcher createAndForceNodeToOpenedState(
    HBaseTestingUtility TEST_UTIL, HRegion region,
    ServerName serverName) throws ZooKeeperConnectionException,
    IOException, KeeperException, NodeExistsException {
  ZooKeeperWatcher zkw = getZooKeeperWatcher(TEST_UTIL);
  ZKAssign.createNodeOffline(zkw, region.getRegionInfo(), serverName);
  int version = ZKAssign.transitionNodeOpening(zkw, region
      .getRegionInfo(), serverName);
  ZKAssign.transitionNodeOpened(zkw, region.getRegionInfo(), serverName,
      version);
  return zkw;
}
 

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 a balance going on at same time as a master failover
 *
 * @throws IOException
 * @throws KeeperException
 * @throws InterruptedException
 */
@Test(timeout = 60000)
public void testBalanceOnMasterFailoverScenarioWithOpenedNode()
    throws IOException, KeeperException, InterruptedException {
  AssignmentManagerWithExtrasForTesting am =
    setUpMockedAssignmentManager(this.server, this.serverManager);
  try {
    createRegionPlanAndBalance(am, SERVERNAME_A, SERVERNAME_B, REGIONINFO);
    startFakeFailedOverMasterAssignmentManager(am, this.watcher);
    while (!am.processRITInvoked) Thread.sleep(1);
    // Now fake the region closing successfully over on the regionserver; the
    // regionserver will have set the region in CLOSED state. This will
    // trigger callback into AM. The below zk close call is from the RS close
    // region handler duplicated here because its down deep in a private
    // method hard to expose.
    int versionid =
      ZKAssign.transitionNodeClosed(this.watcher, REGIONINFO, SERVERNAME_A, -1);
    assertNotSame(versionid, -1);
    Mocking.waitForRegionOfflineInRIT(am, REGIONINFO.getEncodedName());

    // Get the OFFLINE version id.  May have to wait some for it to happen.
    // OPENING below
    while (true) {
      int vid = ZKAssign.getVersion(this.watcher, REGIONINFO);
      if (vid != versionid) {
        versionid = vid;
        break;
      }
    }
    assertNotSame(-1, versionid);
    // This uglyness below is what the openregionhandler on RS side does.
    versionid = ZKAssign.transitionNode(server.getZooKeeper(), REGIONINFO,
      SERVERNAME_A, EventType.M_ZK_REGION_OFFLINE,
      EventType.RS_ZK_REGION_OPENING, versionid);
    assertNotSame(-1, versionid);
    // Move znode from OPENING to OPENED as RS does on successful open.
    versionid = ZKAssign.transitionNodeOpened(this.watcher, REGIONINFO,
      SERVERNAME_B, versionid);
    assertNotSame(-1, versionid);
    am.gate.set(false);
    // Block here until our znode is cleared or until this test times out.
    ZKAssign.blockUntilNoRIT(watcher);
  } finally {
    am.getExecutorService().shutdown();
    am.shutdown();
  }
}
 

import org.apache.hadoop.hbase.zookeeper.ZKAssign; //导入方法依赖的package包/类
@Test(timeout = 60000)
public void testBalanceOnMasterFailoverScenarioWithClosedNode()
    throws IOException, KeeperException, InterruptedException {
  AssignmentManagerWithExtrasForTesting am =
    setUpMockedAssignmentManager(this.server, this.serverManager);
  try {
    createRegionPlanAndBalance(am, SERVERNAME_A, SERVERNAME_B, REGIONINFO);
    startFakeFailedOverMasterAssignmentManager(am, this.watcher);
    while (!am.processRITInvoked) Thread.sleep(1);
    // Now fake the region closing successfully over on the regionserver; the
    // regionserver will have set the region in CLOSED state. This will
    // trigger callback into AM. The below zk close call is from the RS close
    // region handler duplicated here because its down deep in a private
    // method hard to expose.
    int versionid =
      ZKAssign.transitionNodeClosed(this.watcher, REGIONINFO, SERVERNAME_A, -1);
    assertNotSame(versionid, -1);
    am.gate.set(false);
    Mocking.waitForRegionOfflineInRIT(am, REGIONINFO.getEncodedName());

    // Get current versionid else will fail on transition from OFFLINE to
    // OPENING below
    while (true) {
      int vid = ZKAssign.getVersion(this.watcher, REGIONINFO);
      if (vid != versionid) {
        versionid = vid;
        break;
      }
    }
    assertNotSame(-1, versionid);
    // This uglyness below is what the openregionhandler on RS side does.
    versionid = ZKAssign.transitionNode(server.getZooKeeper(), REGIONINFO,
        SERVERNAME_A, EventType.M_ZK_REGION_OFFLINE,
        EventType.RS_ZK_REGION_OPENING, versionid);
    assertNotSame(-1, versionid);
    // Move znode from OPENING to OPENED as RS does on successful open.
    versionid = ZKAssign.transitionNodeOpened(this.watcher, REGIONINFO,
        SERVERNAME_B, versionid);
    assertNotSame(-1, versionid);

    // Block here until our znode is cleared or until this test timesout.
    ZKAssign.blockUntilNoRIT(watcher);
  } finally {
    am.getExecutorService().shutdown();
    am.shutdown();
  }
}
 

import org.apache.hadoop.hbase.zookeeper.ZKAssign; //导入方法依赖的package包/类
@Test(timeout = 60000)
public void testBalanceOnMasterFailoverScenarioWithOfflineNode()
    throws IOException, KeeperException, InterruptedException {
  AssignmentManagerWithExtrasForTesting am =
    setUpMockedAssignmentManager(this.server, this.serverManager);
  try {
    createRegionPlanAndBalance(am, SERVERNAME_A, SERVERNAME_B, REGIONINFO);
    startFakeFailedOverMasterAssignmentManager(am, this.watcher);
    while (!am.processRITInvoked) Thread.sleep(1);
    // Now fake the region closing successfully over on the regionserver; the
    // regionserver will have set the region in CLOSED state. This will
    // trigger callback into AM. The below zk close call is from the RS close
    // region handler duplicated here because its down deep in a private
    // method hard to expose.
    int versionid =
      ZKAssign.transitionNodeClosed(this.watcher, REGIONINFO, SERVERNAME_A, -1);
    assertNotSame(versionid, -1);
    Mocking.waitForRegionOfflineInRIT(am, REGIONINFO.getEncodedName());

    am.gate.set(false);
    // Get current versionid else will fail on transition from OFFLINE to
    // OPENING below
    while (true) {
      int vid = ZKAssign.getVersion(this.watcher, REGIONINFO);
      if (vid != versionid) {
        versionid = vid;
        break;
      }
    }
    assertNotSame(-1, versionid);
    // This uglyness below is what the openregionhandler on RS side does.
    versionid = ZKAssign.transitionNode(server.getZooKeeper(), REGIONINFO,
        SERVERNAME_A, EventType.M_ZK_REGION_OFFLINE,
        EventType.RS_ZK_REGION_OPENING, versionid);
    assertNotSame(-1, versionid);
    // Move znode from OPENING to OPENED as RS does on successful open.
    versionid = ZKAssign.transitionNodeOpened(this.watcher, REGIONINFO,
        SERVERNAME_B, versionid);
    assertNotSame(-1, versionid);
    // Block here until our znode is cleared or until this test timesout.
    ZKAssign.blockUntilNoRIT(watcher);
  } finally {
    am.getExecutorService().shutdown();
    am.shutdown();
  }
}
 

import org.apache.hadoop.hbase.zookeeper.ZKAssign; //导入方法依赖的package包/类
/**
 * Tests AssignmentManager balance function.  Runs a balance moving a region
 * from one server to another mocking regionserver responding over zk.
 * @throws IOException
 * @throws KeeperException
 * @throws InterruptedException
 */
@Test(timeout = 60000)
public void testBalance()
throws IOException, KeeperException, InterruptedException {
  // Create and startup an executor.  This is used by AssignmentManager
  // handling zk callbacks.
  ExecutorService executor = startupMasterExecutor("testBalanceExecutor");

  // We need a mocked catalog tracker.
  CatalogTracker ct = Mockito.mock(CatalogTracker.class);
  LoadBalancer balancer = LoadBalancerFactory.getLoadBalancer(server
      .getConfiguration());
  // Create an AM.
  AssignmentManager am = new AssignmentManager(this.server,
      this.serverManager, ct, balancer, executor);
  try {
    // Make sure our new AM gets callbacks; once registered, can't unregister.
    // Thats ok because we make a new zk watcher for each test.
    this.watcher.registerListenerFirst(am);
    // Call the balance function but fake the region being online first at
    // SERVERNAME_A.  Create a balance plan.
    am.regionOnline(REGIONINFO, SERVERNAME_A);
    // Balance region from A to B.
    RegionPlan plan = new RegionPlan(REGIONINFO, SERVERNAME_A, SERVERNAME_B);
    am.balance(plan);

    // Now fake the region closing successfully over on the regionserver; the
    // regionserver will have set the region in CLOSED state.  This will
    // trigger callback into AM. The below zk close call is from the RS close
    // region handler duplicated here because its down deep in a private
    // method hard to expose.
    int versionid =
      ZKAssign.transitionNodeClosed(this.watcher, REGIONINFO, SERVERNAME_A, -1);
    assertNotSame(versionid, -1);
    // AM is going to notice above CLOSED and queue up a new assign.  The
    // assign will go to open the region in the new location set by the
    // balancer.  The zk node will be OFFLINE waiting for regionserver to
    // transition it through OPENING, OPENED.  Wait till we see the RIT
    // before we proceed.
    Mocking.waitForRegionOfflineInRIT(am, REGIONINFO.getEncodedName());
    // Get current versionid else will fail on transition from OFFLINE to OPENING below
    while (true) {
      int vid = ZKAssign.getVersion(this.watcher, REGIONINFO);
      if (vid != versionid) {
        versionid = vid;
        break;
      }
    }
    assertNotSame(-1, versionid);
    // This uglyness below is what the openregionhandler on RS side does.
    versionid = ZKAssign.transitionNode(server.getZooKeeper(), REGIONINFO,
      SERVERNAME_A, EventType.M_ZK_REGION_OFFLINE,
      EventType.RS_ZK_REGION_OPENING, versionid);
    assertNotSame(-1, versionid);
    // Move znode from OPENING to OPENED as RS does on successful open.
    versionid =
      ZKAssign.transitionNodeOpened(this.watcher, REGIONINFO, SERVERNAME_B, versionid);
    assertNotSame(-1, versionid);
    // Wait on the handler removing the OPENED znode.
    while(am.isRegionInTransition(REGIONINFO) != null) Threads.sleep(1);
  } finally {
    executor.shutdown();
    am.shutdown();
    // Clean up all znodes
    ZKAssign.deleteAllNodes(this.watcher);
  }
}
 

import org.apache.hadoop.hbase.zookeeper.ZKAssign; //导入方法依赖的package包/类
/**
 * Test a balance going on at same time as a master failover
 *
 * @throws IOException
 * @throws KeeperException
 * @throws InterruptedException
 * @throws DeserializationException
 */
@Test(timeout = 60000)
public void testBalanceOnMasterFailoverScenarioWithOpenedNode()
    throws IOException, KeeperException, InterruptedException, ServiceException,
    DeserializationException, CoordinatedStateException {
  AssignmentManagerWithExtrasForTesting am =
    setUpMockedAssignmentManager(this.server, this.serverManager);
  try {
    createRegionPlanAndBalance(am, SERVERNAME_A, SERVERNAME_B, REGIONINFO);
    startFakeFailedOverMasterAssignmentManager(am, this.watcher);
    while (!am.processRITInvoked) Thread.sleep(1);
    // As part of the failover cleanup, the balancing region plan is removed.
    // So a random server will be used to open the region. For testing purpose,
    // let's assume it is going to open on server b:
    am.addPlan(REGIONINFO.getEncodedName(), new RegionPlan(REGIONINFO, null, SERVERNAME_B));

    Mocking.waitForRegionFailedToCloseAndSetToPendingClose(am, REGIONINFO);

    // Now fake the region closing successfully over on the regionserver; the
    // regionserver will have set the region in CLOSED state. This will
    // trigger callback into AM. The below zk close call is from the RS close
    // region handler duplicated here because its down deep in a private
    // method hard to expose.
    int versionid =
      ZKAssign.transitionNodeClosed(this.watcher, REGIONINFO, SERVERNAME_A, -1);
    assertNotSame(versionid, -1);
    Mocking.waitForRegionPendingOpenInRIT(am, REGIONINFO.getEncodedName());

    // Get current versionid else will fail on transition from OFFLINE to
    // OPENING below
    versionid = ZKAssign.getVersion(this.watcher, REGIONINFO);
    assertNotSame(-1, versionid);
    // This uglyness below is what the openregionhandler on RS side does.
    versionid = ZKAssign.transitionNode(server.getZooKeeper(), REGIONINFO,
      SERVERNAME_B, EventType.M_ZK_REGION_OFFLINE,
      EventType.RS_ZK_REGION_OPENING, versionid);
    assertNotSame(-1, versionid);
    // Move znode from OPENING to OPENED as RS does on successful open.
    versionid = ZKAssign.transitionNodeOpened(this.watcher, REGIONINFO,
      SERVERNAME_B, versionid);
    assertNotSame(-1, versionid);
    am.gate.set(false);
    // Block here until our znode is cleared or until this test times out.
    ZKAssign.blockUntilNoRIT(watcher);
  } finally {
    am.getExecutorService().shutdown();
    am.shutdown();
  }
}
 

import org.apache.hadoop.hbase.zookeeper.ZKAssign; //导入方法依赖的package包/类
@Test(timeout = 60000)
public void testBalanceOnMasterFailoverScenarioWithClosedNode()
    throws IOException, KeeperException, InterruptedException, ServiceException,
      DeserializationException, CoordinatedStateException {
  AssignmentManagerWithExtrasForTesting am =
    setUpMockedAssignmentManager(this.server, this.serverManager);
  try {
    createRegionPlanAndBalance(am, SERVERNAME_A, SERVERNAME_B, REGIONINFO);
    startFakeFailedOverMasterAssignmentManager(am, this.watcher);
    while (!am.processRITInvoked) Thread.sleep(1);
    // As part of the failover cleanup, the balancing region plan is removed.
    // So a random server will be used to open the region. For testing purpose,
    // let's assume it is going to open on server b:
    am.addPlan(REGIONINFO.getEncodedName(), new RegionPlan(REGIONINFO, null, SERVERNAME_B));

    Mocking.waitForRegionFailedToCloseAndSetToPendingClose(am, REGIONINFO);

    // Now fake the region closing successfully over on the regionserver; the
    // regionserver will have set the region in CLOSED state. This will
    // trigger callback into AM. The below zk close call is from the RS close
    // region handler duplicated here because its down deep in a private
    // method hard to expose.
    int versionid =
      ZKAssign.transitionNodeClosed(this.watcher, REGIONINFO, SERVERNAME_A, -1);
    assertNotSame(versionid, -1);
    am.gate.set(false);
    Mocking.waitForRegionPendingOpenInRIT(am, REGIONINFO.getEncodedName());

    // Get current versionid else will fail on transition from OFFLINE to
    // OPENING below
    versionid = ZKAssign.getVersion(this.watcher, REGIONINFO);
    assertNotSame(-1, versionid);
    // This uglyness below is what the openregionhandler on RS side does.
    versionid = ZKAssign.transitionNode(server.getZooKeeper(), REGIONINFO,
        SERVERNAME_B, EventType.M_ZK_REGION_OFFLINE,
        EventType.RS_ZK_REGION_OPENING, versionid);
    assertNotSame(-1, versionid);
    // Move znode from OPENING to OPENED as RS does on successful open.
    versionid = ZKAssign.transitionNodeOpened(this.watcher, REGIONINFO,
        SERVERNAME_B, versionid);
    assertNotSame(-1, versionid);

    // Block here until our znode is cleared or until this test timesout.
    ZKAssign.blockUntilNoRIT(watcher);
  } finally {
    am.getExecutorService().shutdown();
    am.shutdown();
  }
}
 

import org.apache.hadoop.hbase.zookeeper.ZKAssign; //导入方法依赖的package包/类
@Test(timeout = 60000)
public void testBalanceOnMasterFailoverScenarioWithOfflineNode()
    throws IOException, KeeperException, InterruptedException, ServiceException,
    DeserializationException, CoordinatedStateException {
  AssignmentManagerWithExtrasForTesting am =
    setUpMockedAssignmentManager(this.server, this.serverManager);
  try {
    createRegionPlanAndBalance(am, SERVERNAME_A, SERVERNAME_B, REGIONINFO);
    startFakeFailedOverMasterAssignmentManager(am, this.watcher);
    while (!am.processRITInvoked) Thread.sleep(1);
    // As part of the failover cleanup, the balancing region plan is removed.
    // So a random server will be used to open the region. For testing purpose,
    // let's assume it is going to open on server b:
    am.addPlan(REGIONINFO.getEncodedName(), new RegionPlan(REGIONINFO, null, SERVERNAME_B));

    Mocking.waitForRegionFailedToCloseAndSetToPendingClose(am, REGIONINFO);

    // Now fake the region closing successfully over on the regionserver; the
    // regionserver will have set the region in CLOSED state. This will
    // trigger callback into AM. The below zk close call is from the RS close
    // region handler duplicated here because its down deep in a private
    // method hard to expose.
    int versionid =
      ZKAssign.transitionNodeClosed(this.watcher, REGIONINFO, SERVERNAME_A, -1);
    assertNotSame(versionid, -1);
    Mocking.waitForRegionPendingOpenInRIT(am, REGIONINFO.getEncodedName());

    am.gate.set(false);
    // Get current versionid else will fail on transition from OFFLINE to
    // OPENING below
    versionid = ZKAssign.getVersion(this.watcher, REGIONINFO);
    assertNotSame(-1, versionid);
    // This uglyness below is what the openregionhandler on RS side does.
    versionid = ZKAssign.transitionNode(server.getZooKeeper(), REGIONINFO,
        SERVERNAME_B, EventType.M_ZK_REGION_OFFLINE,
        EventType.RS_ZK_REGION_OPENING, versionid);
    assertNotSame(-1, versionid);
    // Move znode from OPENING to OPENED as RS does on successful open.
    versionid = ZKAssign.transitionNodeOpened(this.watcher, REGIONINFO,
        SERVERNAME_B, versionid);
    assertNotSame(-1, versionid);
    // Block here until our znode is cleared or until this test timesout.
    ZKAssign.blockUntilNoRIT(watcher);
  } finally {
    am.getExecutorService().shutdown();
    am.shutdown();
  }
}
 

import org.apache.hadoop.hbase.zookeeper.ZKAssign; //导入方法依赖的package包/类
/**
 * Test a balance going on at same time as a master failover
 *
 * @throws IOException
 * @throws KeeperException
 * @throws InterruptedException
 * @throws DeserializationException
 */
@Test(timeout = 60000)
public void testBalanceOnMasterFailoverScenarioWithOpenedNode()
throws IOException, KeeperException, InterruptedException, ServiceException, DeserializationException {
  AssignmentManagerWithExtrasForTesting am =
    setUpMockedAssignmentManager(this.server, this.serverManager);
  try {
    createRegionPlanAndBalance(am, SERVERNAME_A, SERVERNAME_B, REGIONINFO);
    startFakeFailedOverMasterAssignmentManager(am, this.watcher);
    while (!am.processRITInvoked) Thread.sleep(1);
    // As part of the failover cleanup, the balancing region plan is removed.
    // So a random server will be used to open the region. For testing purpose,
    // let's assume it is going to open on server b:
    am.addPlan(REGIONINFO.getEncodedName(), new RegionPlan(REGIONINFO, null, SERVERNAME_B));

    Mocking.waitForRegionFailedToCloseAndSetToPendingClose(am, REGIONINFO);

    // Now fake the region closing successfully over on the regionserver; the
    // regionserver will have set the region in CLOSED state. This will
    // trigger callback into AM. The below zk close call is from the RS close
    // region handler duplicated here because its down deep in a private
    // method hard to expose.
    int versionid =
      ZKAssign.transitionNodeClosed(this.watcher, REGIONINFO, SERVERNAME_A, -1);
    assertNotSame(versionid, -1);
    Mocking.waitForRegionPendingOpenInRIT(am, REGIONINFO.getEncodedName());

    // Get current versionid else will fail on transition from OFFLINE to
    // OPENING below
    versionid = ZKAssign.getVersion(this.watcher, REGIONINFO);
    assertNotSame(-1, versionid);
    // This uglyness below is what the openregionhandler on RS side does.
    versionid = ZKAssign.transitionNode(server.getZooKeeper(), REGIONINFO,
      SERVERNAME_B, EventType.M_ZK_REGION_OFFLINE,
      EventType.RS_ZK_REGION_OPENING, versionid);
    assertNotSame(-1, versionid);
    // Move znode from OPENING to OPENED as RS does on successful open.
    versionid = ZKAssign.transitionNodeOpened(this.watcher, REGIONINFO,
      SERVERNAME_B, versionid);
    assertNotSame(-1, versionid);
    am.gate.set(false);
    // Block here until our znode is cleared or until this test times out.
    ZKAssign.blockUntilNoRIT(watcher);
  } finally {
    am.getExecutorService().shutdown();
    am.shutdown();
  }
}