Java EventType.RS_ZK_REGION_OPENED属性代码示例

private void processOpeningState(HRegionInfo regionInfo) {
  LOG.info("Region has been OPENING for too " + "long, reassigning region="
      + regionInfo.getRegionNameAsString());
  // Should have a ZK node in OPENING state
  try {
    String node = ZKAssign.getNodeName(watcher, regionInfo.getEncodedName());
    Stat stat = new Stat();
    RegionTransitionData dataInZNode = ZKAssign.getDataNoWatch(watcher, node,
        stat);
    if (dataInZNode == null) {
      LOG.warn("Data is null, node " + node + " no longer exists");
      return;
    }
    if (dataInZNode.getEventType() == EventType.RS_ZK_REGION_OPENED) {
      LOG.debug("Region has transitioned to OPENED, allowing "
          + "watched event handlers to process");
      return;
    } else if (dataInZNode.getEventType() != EventType.RS_ZK_REGION_OPENING &&
        dataInZNode.getEventType() != EventType.RS_ZK_REGION_FAILED_OPEN ) {
      LOG.warn("While timing out a region in state OPENING, "
          + "found ZK node in unexpected state: "
          + dataInZNode.getEventType());
      return;
    }
    invokeAssign(regionInfo);
  } catch (KeeperException ke) {
    LOG.error("Unexpected ZK exception timing out CLOSING region", ke);
    return;
  }
  return;
}
 

/**
 * Test we reopen a region once closed.
 * @throws Exception
 */
@Test (timeout=300000) public void testReOpenRegion()
throws Exception {
  MiniHBaseCluster cluster = TEST_UTIL.getHBaseCluster();
  LOG.info("Number of region servers = " +
    cluster.getLiveRegionServerThreads().size());

  int rsIdx = 0;
  HRegionServer regionServer =
    TEST_UTIL.getHBaseCluster().getRegionServer(rsIdx);
  HRegionInfo hri = getNonMetaRegion(regionServer.getOnlineRegions());
  LOG.debug("Asking RS to close region " + hri.getRegionNameAsString());

  AtomicBoolean closeEventProcessed = new AtomicBoolean(false);
  AtomicBoolean reopenEventProcessed = new AtomicBoolean(false);

  EventHandlerListener closeListener =
    new ReopenEventListener(hri.getRegionNameAsString(),
        closeEventProcessed, EventType.RS_ZK_REGION_CLOSED);
  cluster.getMaster().executorService.
    registerListener(EventType.RS_ZK_REGION_CLOSED, closeListener);

  EventHandlerListener openListener =
    new ReopenEventListener(hri.getRegionNameAsString(),
        reopenEventProcessed, EventType.RS_ZK_REGION_OPENED);
  cluster.getMaster().executorService.
    registerListener(EventType.RS_ZK_REGION_OPENED, openListener);

  LOG.info("Unassign " + hri.getRegionNameAsString());
  cluster.getMaster().assignmentManager.unassign(hri);

  while (!closeEventProcessed.get()) {
    Threads.sleep(100);
  }

  while (!reopenEventProcessed.get()) {
    Threads.sleep(100);
  }

  LOG.info("Done with testReOpenRegion");
}
 

/**
 * This test shows how a region won't be able to be assigned to a RS
 * if it's already "processing" it.
 * @throws Exception
 */
@Test
public void testRSAlreadyProcessingRegion() throws Exception {
  LOG.info("starting testRSAlreadyProcessingRegion");
  MiniHBaseCluster cluster = TEST_UTIL.getHBaseCluster();

  HRegionServer hr0 =
      cluster.getLiveRegionServerThreads().get(0).getRegionServer();
  HRegionServer hr1 =
      cluster.getLiveRegionServerThreads().get(1).getRegionServer();
  HRegionInfo hri = getNonMetaRegion(hr0.getOnlineRegions());

  // Fake that hr1 is processing the region. At top of this test we made a
  // regionserver that gave access addRegionsInTransition. Need to cast as
  // TestZKBasedOpenCloseRegionRegionServer.
  ((TestZKBasedOpenCloseRegionRegionServer) hr1).addRegionsInTransition(hri, "OPEN");

  AtomicBoolean reopenEventProcessed = new AtomicBoolean(false);
  EventHandlerListener openListener =
    new ReopenEventListener(hri.getRegionNameAsString(),
        reopenEventProcessed, EventType.RS_ZK_REGION_OPENED);
  cluster.getMaster().executorService.
    registerListener(EventType.RS_ZK_REGION_OPENED, openListener);

  // now ask the master to move the region to hr1, will fail
  TEST_UTIL.getHBaseAdmin().move(hri.getEncodedNameAsBytes(),
      Bytes.toBytes(hr1.getServerName().toString()));

  // make sure the region came back
  assertEquals(hr1.getOnlineRegion(hri.getEncodedNameAsBytes()), null);

  // remove the block and reset the boolean
  hr1.removeFromRegionsInTransition(hri);
  reopenEventProcessed.set(false);
  
  // now try moving a region when there is no region in transition.
  hri = getNonMetaRegion(hr1.getOnlineRegions());

  openListener =
    new ReopenEventListener(hri.getRegionNameAsString(),
        reopenEventProcessed, EventType.RS_ZK_REGION_OPENED);

  cluster.getMaster().executorService.
    registerListener(EventType.RS_ZK_REGION_OPENED, openListener);
  
  TEST_UTIL.getHBaseAdmin().move(hri.getEncodedNameAsBytes(),
      Bytes.toBytes(hr0.getServerName().toString()));

  while (!reopenEventProcessed.get()) {
    Threads.sleep(100);
  }

  // make sure the region has moved from the original RS
  assertTrue(hr1.getOnlineRegion(hri.getEncodedNameAsBytes()) == null);

}
 

/**
 * the region is not deployed when the table is disabled.
 */
@Test
public void testRegionShouldNotBeDeployed() throws Exception {
  String table = "tableRegionShouldNotBeDeployed";
  try {
    LOG.info("Starting testRegionShouldNotBeDeployed.");
    MiniHBaseCluster cluster = TEST_UTIL.getHBaseCluster();
    assertTrue(cluster.waitForActiveAndReadyMaster());

    // Create a ZKW to use in the test
    ZooKeeperWatcher zkw = HBaseTestingUtility.getZooKeeperWatcher(TEST_UTIL);

    FileSystem filesystem = FileSystem.get(conf);
    Path rootdir = filesystem.makeQualified(new Path(conf
        .get(HConstants.HBASE_DIR)));

    byte[][] SPLIT_KEYS = new byte[][] { new byte[0], Bytes.toBytes("aaa"),
        Bytes.toBytes("bbb"), Bytes.toBytes("ccc"), Bytes.toBytes("ddd") };
    HTableDescriptor htdDisabled = new HTableDescriptor(Bytes.toBytes(table));
    htdDisabled.addFamily(new HColumnDescriptor(FAM));

    // Write the .tableinfo
    FSTableDescriptors
        .createTableDescriptor(filesystem, rootdir, htdDisabled);
    List<HRegionInfo> disabledRegions = TEST_UTIL.createMultiRegionsInMeta(
        TEST_UTIL.getConfiguration(), htdDisabled, SPLIT_KEYS);

    // Let's just assign everything to first RS
    HRegionServer hrs = cluster.getRegionServer(0);
    ServerName serverName = hrs.getServerName();

    // create region files.
    TEST_UTIL.getHBaseAdmin().disableTable(table);
    TEST_UTIL.getHBaseAdmin().enableTable(table);

    // Region of disable table was opened on RS
    TEST_UTIL.getHBaseAdmin().disableTable(table);
    HRegionInfo region = disabledRegions.remove(0);
    ZKAssign.createNodeOffline(zkw, region, serverName);
    hrs.openRegion(region);

    int iTimes = 0;
    while (true) {
      RegionTransitionData rtd = ZKAssign.getData(zkw,
          region.getEncodedName());
      if (rtd != null && rtd.getEventType() == EventType.RS_ZK_REGION_OPENED) {
        break;
      }
      Thread.sleep(100);
      iTimes++;
      if (iTimes >= REGION_ONLINE_TIMEOUT) {
        break;
      }
    }
    assertTrue(iTimes < REGION_ONLINE_TIMEOUT);

    HBaseFsck hbck = doFsck(conf, false);
    assertErrors(hbck, new ERROR_CODE[] { ERROR_CODE.SHOULD_NOT_BE_DEPLOYED });

    // fix this fault
    doFsck(conf, true);

    // check result
    assertNoErrors(doFsck(conf, false));
  } finally {
    TEST_UTIL.getHBaseAdmin().enableTable(table);
    deleteTable(table);
  }
}