Java ZKAssign.transitionNode方法代码示例

import org.apache.hadoop.hbase.zookeeper.ZKAssign; //导入方法依赖的package包/类
/**
 * Transition ZK node from OFFLINE to OPENING.
 * @param encodedName Name of the znode file (Region encodedName is the znode
 * name).
 * @param versionOfOfflineNode - version Of OfflineNode that needs to be compared
 * before changing the node's state from OFFLINE
 * @return True if successful transition.
 */
boolean transitionZookeeperOfflineToOpening(final String encodedName,
    int versionOfOfflineNode) {
  // TODO: should also handle transition from CLOSED?
  try {
    // Initialize the znode version.
    this.version = ZKAssign.transitionNode(server.getZooKeeper(), regionInfo,
        server.getServerName(), EventType.M_ZK_REGION_OFFLINE,
        EventType.RS_ZK_REGION_OPENING, versionOfOfflineNode);
  } catch (KeeperException e) {
    LOG.error("Error transition from OFFLINE to OPENING for region=" +
      encodedName, e);
    this.version = -1;
    return false;
  }
  boolean b = isGoodVersion();
  if (!b) {
    LOG.warn("Failed transition from OFFLINE to OPENING for region=" +
      encodedName);
  }
  return b;
}
 

import org.apache.hadoop.hbase.zookeeper.ZKAssign; //导入方法依赖的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.zookeeper.ZKAssign; //导入方法依赖的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.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包/类
@Test
public void testUnassignWithSplitAtSameTime() throws KeeperException, IOException {
  // Region to use in test.
  final HRegionInfo hri = HRegionInfo.FIRST_META_REGIONINFO;
  // First amend the servermanager mock so that when we do send close of the
  // first meta region on SERVERNAME_A, it will return true rather than
  // default null.
  Mockito.when(this.serverManager.sendRegionClose(SERVERNAME_A, hri, -1)).thenReturn(true);
  // 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, null, null, master.getTableLockManager());
  try {
    // First make sure my mock up basically works.  Unassign a region.
    unassign(am, SERVERNAME_A, hri);
    // This delete will fail if the previous unassign did wrong thing.
    ZKAssign.deleteClosingNode(this.watcher, hri, SERVERNAME_A);
    // Now put a SPLITTING region in the way.  I don't have to assert it
    // go put in place.  This method puts it in place then asserts it still
    // owns it by moving state from SPLITTING to SPLITTING.
    int version = createNodeSplitting(this.watcher, hri, SERVERNAME_A);
    // Now, retry the unassign with the SPLTTING in place.  It should just
    // complete without fail; a sort of 'silent' recognition that the
    // region to unassign has been split and no longer exists: TOOD: what if
    // the split fails and the parent region comes back to life?
    unassign(am, SERVERNAME_A, hri);
    // This transition should fail if the znode has been messed with.
    ZKAssign.transitionNode(this.watcher, hri, SERVERNAME_A,
      EventType.RS_ZK_REGION_SPLITTING, EventType.RS_ZK_REGION_SPLITTING, version);
    assertFalse(am.getRegionStates().isRegionInTransition(hri));
  } finally {
    am.shutdown();
  }
}
 

import org.apache.hadoop.hbase.zookeeper.ZKAssign; //导入方法依赖的package包/类
private static int transitionNodeSplitting(final ZooKeeperWatcher zkw,
    final HRegionInfo parent,
    final ServerName serverName, final int version)
throws KeeperException, IOException {
  return ZKAssign.transitionNode(zkw, parent, serverName,
    EventType.RS_ZK_REGION_SPLITTING, EventType.RS_ZK_REGION_SPLITTING, version);
}
 

import org.apache.hadoop.hbase.zookeeper.ZKAssign; //导入方法依赖的package包/类
/**
 * Test the scenario when the master is in failover and trying to process a
 * region which is in Opening state on a dead RS. Master will force offline the
 * region and put it in transition. AM relies on SSH to reassign it.
 */
@Test(timeout = 60000)
public void testRegionInOpeningStateOnDeadRSWhileMasterFailover() throws IOException,
    KeeperException, ServiceException, CoordinatedStateException, InterruptedException {
  AssignmentManagerWithExtrasForTesting am = setUpMockedAssignmentManager(
    this.server, this.serverManager);
  ZKAssign.createNodeOffline(this.watcher, REGIONINFO, SERVERNAME_A);
  int version = ZKAssign.getVersion(this.watcher, REGIONINFO);
  ZKAssign.transitionNode(this.watcher, REGIONINFO, SERVERNAME_A, EventType.M_ZK_REGION_OFFLINE,
      EventType.RS_ZK_REGION_OPENING, version);
  RegionTransition rt = RegionTransition.createRegionTransition(EventType.RS_ZK_REGION_OPENING,
      REGIONINFO.getRegionName(), SERVERNAME_A, HConstants.EMPTY_BYTE_ARRAY);
  version = ZKAssign.getVersion(this.watcher, REGIONINFO);
  Mockito.when(this.serverManager.isServerOnline(SERVERNAME_A)).thenReturn(false);
  am.getRegionStates().logSplit(SERVERNAME_A); // Assume log splitting is done
  am.getRegionStates().createRegionState(REGIONINFO);
  am.gate.set(false);

  BaseCoordinatedStateManager cp = new ZkCoordinatedStateManager();
  cp.initialize(server);
  cp.start();

  OpenRegionCoordination orc = cp.getOpenRegionCoordination();
  ZkOpenRegionCoordination.ZkOpenRegionDetails zkOrd =
    new ZkOpenRegionCoordination.ZkOpenRegionDetails();
  zkOrd.setServerName(server.getServerName());
  zkOrd.setVersion(version);

  assertFalse(am.processRegionsInTransition(rt, REGIONINFO, orc, zkOrd));
  am.getTableStateManager().setTableState(REGIONINFO.getTable(), Table.State.ENABLED);
  processServerShutdownHandler(am, false);
  // Waiting for the assignment to get completed.
  while (!am.gate.get()) {
    Thread.sleep(10);
  }
  assertTrue("The region should be assigned immediately.", null != am.regionPlans.get(REGIONINFO
      .getEncodedName()));
  am.shutdown();
}
 

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包/类
/**
 * This tests region assignment on a simulated restarted server
 */
@Test (timeout=120000)
public void testAssignRegionOnRestartedServer() throws Exception {
  String table = "testAssignRegionOnRestartedServer";
  TEST_UTIL.getMiniHBaseCluster().getConf().setInt("hbase.assignment.maximum.attempts", 20);
  TEST_UTIL.getMiniHBaseCluster().stopMaster(0);
  TEST_UTIL.getMiniHBaseCluster().startMaster(); //restart the master so that conf take into affect

  ServerName deadServer = null;
  HMaster master = null;
  try {
    HTableDescriptor desc = new HTableDescriptor(TableName.valueOf(table));
    desc.addFamily(new HColumnDescriptor(FAMILY));
    admin.createTable(desc);

    Table meta = new HTable(conf, TableName.META_TABLE_NAME);
    final HRegionInfo hri = new HRegionInfo(
      desc.getTableName(), Bytes.toBytes("A"), Bytes.toBytes("Z"));
    MetaTableAccessor.addRegionToMeta(meta, hri);

    master = TEST_UTIL.getHBaseCluster().getMaster();
    Set<ServerName> onlineServers = master.serverManager.getOnlineServers().keySet();
    assertFalse("There should be some servers online", onlineServers.isEmpty());

    // Use the first server as the destination server
    ServerName destServer = onlineServers.iterator().next();

    // Created faked dead server
    deadServer = ServerName.valueOf(destServer.getHostname(),
        destServer.getPort(), destServer.getStartcode() - 100L);
    master.serverManager.recordNewServerWithLock(deadServer, ServerLoad.EMPTY_SERVERLOAD);

    final AssignmentManager am = master.getAssignmentManager();
    RegionPlan plan = new RegionPlan(hri, null, deadServer);
    am.addPlan(hri.getEncodedName(), plan);
    master.assignRegion(hri);

    int version = ZKAssign.transitionNode(master.getZooKeeper(), hri,
      destServer, EventType.M_ZK_REGION_OFFLINE,
      EventType.RS_ZK_REGION_OPENING, 0);
    assertEquals("TansitionNode should fail", -1, version);

    TEST_UTIL.waitFor(60000, new Waiter.Predicate<Exception>() {
      @Override
      public boolean evaluate() throws Exception {
        return ! am.getRegionStates().isRegionInTransition(hri);
      }
    });

  assertFalse("Region should be assigned", am.getRegionStates().isRegionInTransition(hri));
  } finally {
    if (deadServer != null) {
      master.serverManager.expireServer(deadServer);
    }

    TEST_UTIL.deleteTable(Bytes.toBytes(table));

    // reset the value for other tests
    TEST_UTIL.getMiniHBaseCluster().getConf().setInt("hbase.assignment.maximum.attempts", 3);
    ServerName masterServerName = TEST_UTIL.getMiniHBaseCluster().getMaster().getServerName();
    TEST_UTIL.getMiniHBaseCluster().stopMaster(masterServerName);
    TEST_UTIL.getMiniHBaseCluster().startMaster();
    // Wait till master is active and is initialized
    while (TEST_UTIL.getMiniHBaseCluster().getMaster() == null ||
        !TEST_UTIL.getMiniHBaseCluster().getMaster().isInitialized()) {
      Threads.sleep(1);
    }
  }
}
 

import org.apache.hadoop.hbase.zookeeper.ZKAssign; //导入方法依赖的package包/类
/**
 * TestCase verifies that the regionPlan is updated whenever a region fails to open
 * and the master tries to process RS_ZK_FAILED_OPEN state.(HBASE-5546).
 */
@Test(timeout = 60000)
public void testRegionPlanIsUpdatedWhenRegionFailsToOpen() throws IOException, KeeperException,
    ServiceException, InterruptedException, CoordinatedStateException {
  this.server.getConfiguration().setClass(
    HConstants.HBASE_MASTER_LOADBALANCER_CLASS, MockedLoadBalancer.class,
    LoadBalancer.class);
  AssignmentManagerWithExtrasForTesting am = setUpMockedAssignmentManager(
    this.server, this.serverManager);
  try {
    // Boolean variable used for waiting until randomAssignment is called and
    // new
    // plan is generated.
    AtomicBoolean gate = new AtomicBoolean(false);
    if (balancer instanceof MockedLoadBalancer) {
      ((MockedLoadBalancer) balancer).setGateVariable(gate);
    }
    ZKAssign.createNodeOffline(this.watcher, REGIONINFO, SERVERNAME_A);
    int v = ZKAssign.getVersion(this.watcher, REGIONINFO);
    ZKAssign.transitionNode(this.watcher, REGIONINFO, SERVERNAME_A,
        EventType.M_ZK_REGION_OFFLINE, EventType.RS_ZK_REGION_FAILED_OPEN, v);
    String path = ZKAssign.getNodeName(this.watcher, REGIONINFO
        .getEncodedName());
    am.getRegionStates().updateRegionState(
      REGIONINFO, State.OPENING, SERVERNAME_A);
    // a dummy plan inserted into the regionPlans. This plan is cleared and
    // new one is formed
    am.regionPlans.put(REGIONINFO.getEncodedName(), new RegionPlan(
        REGIONINFO, null, SERVERNAME_A));
    RegionPlan regionPlan = am.regionPlans.get(REGIONINFO.getEncodedName());
    List<ServerName> serverList = new ArrayList<ServerName>(2);
    serverList.add(SERVERNAME_B);
    Mockito.when(
        this.serverManager.createDestinationServersList(SERVERNAME_A))
        .thenReturn(serverList);
    am.nodeDataChanged(path);
    // here we are waiting until the random assignment in the load balancer is
    // called.
    while (!gate.get()) {
      Thread.sleep(10);
    }
    // new region plan may take some time to get updated after random
    // assignment is called and
    // gate is set to true.
    RegionPlan newRegionPlan = am.regionPlans
        .get(REGIONINFO.getEncodedName());
    while (newRegionPlan == null) {
      Thread.sleep(10);
      newRegionPlan = am.regionPlans.get(REGIONINFO.getEncodedName());
    }
    // the new region plan created may contain the same RS as destination but
    // it should
    // be new plan.
    assertNotSame("Same region plan should not come", regionPlan,
        newRegionPlan);
    assertTrue("Destination servers should be different.", !(regionPlan
        .getDestination().equals(newRegionPlan.getDestination())));

    Mocking.waitForRegionPendingOpenInRIT(am, REGIONINFO.getEncodedName());
  } finally {
    this.server.getConfiguration().setClass(
        HConstants.HBASE_MASTER_LOADBALANCER_CLASS, SimpleLoadBalancer.class,
        LoadBalancer.class);
    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 DeserializationException
 */
@Test (timeout=180000)
public void testBalance() throws IOException, KeeperException, DeserializationException,
    InterruptedException, CoordinatedStateException {
  // Create and startup an executor.  This is used by AssignmentManager
  // handling zk callbacks.
  ExecutorService executor = startupMasterExecutor("testBalanceExecutor");

  // We need a mocked catalog tracker.
  LoadBalancer balancer = LoadBalancerFactory.getLoadBalancer(server
      .getConfiguration());
  // Create an AM.
  AssignmentManager am = new AssignmentManager(this.server,
    this.serverManager, balancer, executor, null, master.getTableLockManager());
  am.failoverCleanupDone.set(true);
  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);

    RegionStates regionStates = am.getRegionStates();
    // Must be failed to close since the server is fake
    assertTrue(regionStates.isRegionInTransition(REGIONINFO)
      && regionStates.isRegionInState(REGIONINFO, State.FAILED_CLOSE));
    // Move it back to pending_close
    regionStates.updateRegionState(REGIONINFO, State.PENDING_CLOSE);

    // 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 OFFLINE
    // zk node before we proceed.
    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);
    // Wait on the handler removing the OPENED znode.
    while(regionStates.isRegionInTransition(REGIONINFO)) 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 {
  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包/类
/**
 * TestCase verifies that the regionPlan is updated whenever a region fails to open
 * and the master tries to process RS_ZK_FAILED_OPEN state.(HBASE-5546).
 */
@Test
public void testRegionPlanIsUpdatedWhenRegionFailsToOpen() throws IOException, KeeperException,
    ServiceException, InterruptedException {
  this.server.getConfiguration().setClass(HConstants.HBASE_MASTER_LOADBALANCER_CLASS,
      MockedLoadBalancer.class, LoadBalancer.class);
  AssignmentManagerWithExtrasForTesting am = setUpMockedAssignmentManager(this.server,
      this.serverManager);
  try {
    // Boolean variable used for waiting until randomAssignment is called and new
    // plan is generated.
    AtomicBoolean gate = new AtomicBoolean(false);
    if (balancer instanceof MockedLoadBalancer) {
      ((MockedLoadBalancer) balancer).setGateVariable(gate);
    }
    ZKAssign.createNodeOffline(this.watcher, REGIONINFO, SERVERNAME_A);
    int v = ZKAssign.getVersion(this.watcher, REGIONINFO);
    ZKAssign.transitionNode(this.watcher, REGIONINFO, SERVERNAME_A, EventType.M_ZK_REGION_OFFLINE,
        EventType.RS_ZK_REGION_FAILED_OPEN, v);
    String path = ZKAssign.getNodeName(this.watcher, REGIONINFO.getEncodedName());
    RegionState state = new RegionState(REGIONINFO, State.OPENING, System.currentTimeMillis(),
        SERVERNAME_A);
    am.regionsInTransition.put(REGIONINFO.getEncodedName(), state);
    // a dummy plan inserted into the regionPlans. This plan is cleared and new one is formed
    am.regionPlans.put(REGIONINFO.getEncodedName(), new RegionPlan(REGIONINFO, null, SERVERNAME_A));
    RegionPlan regionPlan = am.regionPlans.get(REGIONINFO.getEncodedName());
    List<ServerName> serverList = new ArrayList<ServerName>(2);
    serverList.add(SERVERNAME_B);
    Mockito.when(this.serverManager.getOnlineServersList()).thenReturn(serverList);
    am.nodeDataChanged(path);
    // here we are waiting until the random assignment in the load balancer is called.
    while (!gate.get()) {
      Thread.sleep(10);
    }
    // new region plan may take some time to get updated after random assignment is called and
    // gate is set to true.
    RegionPlan newRegionPlan = am.regionPlans.get(REGIONINFO.getEncodedName());
    while (newRegionPlan == null) {
      Thread.sleep(10);
      newRegionPlan = am.regionPlans.get(REGIONINFO.getEncodedName());
    }
    // the new region plan created may contain the same RS as destination but it should
    // be new plan.
    assertNotSame("Same region plan should not come", regionPlan, newRegionPlan);
    assertTrue("Destnation servers should be different.", !(regionPlan.getDestination().equals(
      newRegionPlan.getDestination())));
    Mocking.waitForRegionOfflineInRIT(am, REGIONINFO.getEncodedName());
  } finally {
    this.server.getConfiguration().setClass(HConstants.HBASE_MASTER_LOADBALANCER_CLASS,
      DefaultLoadBalancer.class, LoadBalancer.class);
    am.shutdown();
  }
}
 

import org.apache.hadoop.hbase.zookeeper.ZKAssign; //导入方法依赖的package包/类
@Test(timeout = 60000)
public void testBalanceOnMasterFailoverScenarioWithOfflineNode()
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());

    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();
  }
}