Java ZKAssign.getVersion方法代码示例

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包/类
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 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 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, 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);
  CatalogTracker ct = Mockito.mock(CatalogTracker.class);
  assertFalse(am.processRegionsInTransition(rt, REGIONINFO, version));
  am.getZKTable().setEnabledTable(REGIONINFO.getTable());
  processServerShutdownHandler(ct, 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()));
}
 

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包/类
/**
 * 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 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包/类
/**
 * 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包/类
/**
 * 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 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();
  }
}