Java ZKSplitLog.getFileName方法代码示例

import org.apache.hadoop.hbase.zookeeper.ZKSplitLog; //导入方法依赖的package包/类
public HLogSplitterHandler(final Server server, String curTask,
    final MutableInt curTaskZKVersion,
    CancelableProgressable reporter,
    AtomicInteger inProgressTasks, TaskExecutor splitTaskExecutor) {
 super(server, EventType.RS_LOG_REPLAY);
  this.curTask = curTask;
  this.wal = ZKSplitLog.getFileName(curTask);
  this.reporter = reporter;
  this.inProgressTasks = inProgressTasks;
  this.inProgressTasks.incrementAndGet();
  this.serverName = server.getServerName();
  this.zkw = server.getZooKeeper();
  this.curTaskZKVersion = curTaskZKVersion;
  this.splitTaskExecutor = splitTaskExecutor;
}
 

import org.apache.hadoop.hbase.zookeeper.ZKSplitLog; //导入方法依赖的package包/类
@Override
public String getWALFile() {
  return ZKSplitLog.getFileName(taskNode);
}
 

import org.apache.hadoop.hbase.zookeeper.ZKSplitLog; //导入方法依赖的package包/类
@Test(timeout=60000)
public void testRescan() throws Exception {
  LOG.info("testRescan");
  SplitLogCounters.resetCounters();
  final ServerName SRV = ServerName.valueOf("svr,1,1");
  RegionServerServices mockedRS = getRegionServer(SRV);
  slw = new SplitLogWorker(ds, TEST_UTIL.getConfiguration(), mockedRS, neverEndingTask);
  slw.start();
  Thread.yield(); // let the worker start
  Thread.sleep(100);

  String task = ZKSplitLog.getEncodedNodeName(zkw, "task");
  SplitLogTask slt = new SplitLogTask.Unassigned(MANAGER, this.mode);
  zkw.getRecoverableZooKeeper().create(task,slt.toByteArray(), Ids.OPEN_ACL_UNSAFE,
    CreateMode.PERSISTENT);

  waitForCounter(SplitLogCounters.tot_wkr_task_acquired, 0, 1, WAIT_TIME);
  // now the worker is busy doing the above task

  // preempt the task, have it owned by another worker
  ZKUtil.setData(zkw, task, slt.toByteArray());
  waitForCounter(SplitLogCounters.tot_wkr_preempt_task, 0, 1, WAIT_TIME);

  // create a RESCAN node
  String rescan = ZKSplitLog.getEncodedNodeName(zkw, "RESCAN");
  rescan = zkw.getRecoverableZooKeeper().create(rescan, slt.toByteArray(), Ids.OPEN_ACL_UNSAFE,
    CreateMode.PERSISTENT_SEQUENTIAL);

  waitForCounter(SplitLogCounters.tot_wkr_task_acquired, 1, 2, WAIT_TIME);
  // RESCAN node might not have been processed if the worker became busy
  // with the above task. preempt the task again so that now the RESCAN
  // node is processed
  ZKUtil.setData(zkw, task, slt.toByteArray());
  waitForCounter(SplitLogCounters.tot_wkr_preempt_task, 1, 2, WAIT_TIME);
  waitForCounter(SplitLogCounters.tot_wkr_task_acquired_rescan, 0, 1, WAIT_TIME);

  List<String> nodes = ZKUtil.listChildrenNoWatch(zkw, zkw.splitLogZNode);
  LOG.debug(nodes);
  int num = 0;
  for (String node : nodes) {
    num++;
    if (node.startsWith("RESCAN")) {
      String name = ZKSplitLog.getEncodedNodeName(zkw, node);
      String fn = ZKSplitLog.getFileName(name);
      byte [] data = ZKUtil.getData(zkw, ZKUtil.joinZNode(zkw.splitLogZNode, fn));
      slt = SplitLogTask.parseFrom(data);
      assertTrue(slt.toString(), slt.isDone(SRV));
    }
  }
  assertEquals(2, num);
}
 

import org.apache.hadoop.hbase.zookeeper.ZKSplitLog; //导入方法依赖的package包/类
@Test(timeout=60000)
public void testRescan() throws Exception {
  LOG.info("testRescan");
  ZKSplitLog.Counters.resetCounters();
  slw = new SplitLogWorker(zkw, TEST_UTIL.getConfiguration(),
      "svr", neverEndingTask);
  slw.start();
  Thread.yield(); // let the worker start
  Thread.sleep(200);

  String task = ZKSplitLog.getEncodedNodeName(zkw, "task");
  zkw.getRecoverableZooKeeper().create(task,
    TaskState.TASK_UNASSIGNED.get("manager"), Ids.OPEN_ACL_UNSAFE,
    CreateMode.PERSISTENT);

  waitForCounter(tot_wkr_task_acquired, 0, 1, WAIT_TIME);
  // now the worker is busy doing the above task

  // preempt the task, have it owned by another worker
  ZKUtil.setData(zkw, task, TaskState.TASK_UNASSIGNED.get("manager"));
  waitForCounter(tot_wkr_preempt_task, 0, 1, WAIT_TIME);

  // create a RESCAN node
  String rescan = ZKSplitLog.getEncodedNodeName(zkw, "RESCAN");
  rescan = zkw.getRecoverableZooKeeper().create(rescan,
    TaskState.TASK_UNASSIGNED.get("manager"), Ids.OPEN_ACL_UNSAFE,
    CreateMode.PERSISTENT_SEQUENTIAL);

  waitForCounter(tot_wkr_task_acquired, 1, 2, WAIT_TIME);
  // RESCAN node might not have been processed if the worker became busy
  // with the above task. preempt the task again so that now the RESCAN
  // node is processed
  ZKUtil.setData(zkw, task, TaskState.TASK_UNASSIGNED.get("manager"));
  waitForCounter(tot_wkr_preempt_task, 1, 2, WAIT_TIME);
  waitForCounter(tot_wkr_task_acquired_rescan, 0, 1, WAIT_TIME);

  List<String> nodes = ZKUtil.listChildrenNoWatch(zkw, zkw.splitLogZNode);
  LOG.debug(nodes);
  int num = 0;
  for (String node : nodes) {
    num++;
    if (node.startsWith("RESCAN")) {
      String name = ZKSplitLog.getEncodedNodeName(zkw, node);
      String fn = ZKSplitLog.getFileName(name);
      byte [] data = ZKUtil.getData(zkw, ZKUtil.joinZNode(zkw.splitLogZNode, fn));
      String datastr = Bytes.toString(data);
      assertTrue("data=" + datastr, TaskState.TASK_DONE.equals(data, "svr"));
    }
  }
  assertEquals(2, num);
}
 

import org.apache.hadoop.hbase.zookeeper.ZKSplitLog; //导入方法依赖的package包/类
/**
 * It removes stale recovering regions under /hbase/recovering-regions/[encoded region name]
 * during master initialization phase.
 * @param failedServers A set of known failed servers
 * @throws KeeperException
 */
void removeStaleRecoveringRegionsFromZK(final Set<ServerName> failedServers)
    throws KeeperException {

  if (!this.distributedLogReplay) {
    // remove any regions in recovery from ZK which could happen when we turn the feature on
    // and later turn it off
    ZKUtil.deleteChildrenRecursively(watcher, watcher.recoveringRegionsZNode);
    // the function is only used in distributedLogReplay mode when master is in initialization
    return;
  }

  Set<String> knownFailedServers = new HashSet<String>();
  if (failedServers != null) {
    for (ServerName tmpServerName : failedServers) {
      knownFailedServers.add(tmpServerName.getServerName());
    }
  }

  this.recoveringRegionLock.lock();
  try {
    List<String> tasks = ZKUtil.listChildrenNoWatch(watcher, watcher.splitLogZNode);
    if (tasks != null) {
      for (String t : tasks) {
        byte[] data = ZKUtil.getData(this.watcher, ZKUtil.joinZNode(watcher.splitLogZNode, t));
        if (data != null) {
          SplitLogTask slt = null;
          try {
            slt = SplitLogTask.parseFrom(data);
          } catch (DeserializationException e) {
            LOG.warn("Failed parse data for znode " + t, e);
          }
          if (slt != null && slt.isDone()) {
            continue;
          }
        }
        // decode the file name
        t = ZKSplitLog.getFileName(t);
        ServerName serverName = HLogUtil.getServerNameFromHLogDirectoryName(new Path(t));
        if (serverName != null) {
          knownFailedServers.add(serverName.getServerName());
        } else {
          LOG.warn("Found invalid WAL log file name:" + t);
        }
      }
    }

    // remove recovering regions which doesn't have any RS associated with it
    List<String> regions = ZKUtil.listChildrenNoWatch(watcher, watcher.recoveringRegionsZNode);
    if (regions != null) {
      for (String region : regions) {
        String nodePath = ZKUtil.joinZNode(watcher.recoveringRegionsZNode, region);
        List<String> regionFailedServers = ZKUtil.listChildrenNoWatch(watcher, nodePath);
        if (regionFailedServers == null || regionFailedServers.isEmpty()) {
          ZKUtil.deleteNode(watcher, nodePath);
          continue;
        }
        boolean needMoreRecovery = false;
        for (String tmpFailedServer : regionFailedServers) {
          if (knownFailedServers.contains(tmpFailedServer)) {
            needMoreRecovery = true;
            break;
          }
        }
        if (!needMoreRecovery) {
          ZKUtil.deleteNodeRecursively(watcher, nodePath);
        }
      }
    }
  } finally {
    this.recoveringRegionLock.unlock();
  }
}
 

import org.apache.hadoop.hbase.zookeeper.ZKSplitLog; //导入方法依赖的package包/类
@Test(timeout=60000)
public void testRescan() throws Exception {
  LOG.info("testRescan");
  SplitLogCounters.resetCounters();
  final ServerName SRV = ServerName.valueOf("svr,1,1");
  RegionServerServices mockedRS = getRegionServer(SRV);
  slw = new SplitLogWorker(zkw, TEST_UTIL.getConfiguration(), mockedRS, neverEndingTask);
  slw.start();
  Thread.yield(); // let the worker start
  Thread.sleep(100);

  String task = ZKSplitLog.getEncodedNodeName(zkw, "task");
  SplitLogTask slt = new SplitLogTask.Unassigned(MANAGER);
  zkw.getRecoverableZooKeeper().create(task,slt.toByteArray(), Ids.OPEN_ACL_UNSAFE,
    CreateMode.PERSISTENT);

  waitForCounter(SplitLogCounters.tot_wkr_task_acquired, 0, 1, WAIT_TIME);
  // now the worker is busy doing the above task

  // preempt the task, have it owned by another worker
  ZKUtil.setData(zkw, task, slt.toByteArray());
  waitForCounter(SplitLogCounters.tot_wkr_preempt_task, 0, 1, WAIT_TIME);

  // create a RESCAN node
  String rescan = ZKSplitLog.getEncodedNodeName(zkw, "RESCAN");
  rescan = zkw.getRecoverableZooKeeper().create(rescan, slt.toByteArray(), Ids.OPEN_ACL_UNSAFE,
    CreateMode.PERSISTENT_SEQUENTIAL);

  waitForCounter(SplitLogCounters.tot_wkr_task_acquired, 1, 2, WAIT_TIME);
  // RESCAN node might not have been processed if the worker became busy
  // with the above task. preempt the task again so that now the RESCAN
  // node is processed
  ZKUtil.setData(zkw, task, slt.toByteArray());
  waitForCounter(SplitLogCounters.tot_wkr_preempt_task, 1, 2, WAIT_TIME);
  waitForCounter(SplitLogCounters.tot_wkr_task_acquired_rescan, 0, 1, WAIT_TIME);

  List<String> nodes = ZKUtil.listChildrenNoWatch(zkw, zkw.splitLogZNode);
  LOG.debug(nodes);
  int num = 0;
  for (String node : nodes) {
    num++;
    if (node.startsWith("RESCAN")) {
      String name = ZKSplitLog.getEncodedNodeName(zkw, node);
      String fn = ZKSplitLog.getFileName(name);
      byte [] data = ZKUtil.getData(zkw, ZKUtil.joinZNode(zkw.splitLogZNode, fn));
      slt = SplitLogTask.parseFrom(data);
      assertTrue(slt.toString(), slt.isDone(SRV));
    }
  }
  assertEquals(2, num);
}
 

import org.apache.hadoop.hbase.zookeeper.ZKSplitLog; //导入方法依赖的package包/类
@Test(timeout=60000)
public void testRescan() throws Exception {
  LOG.info("testRescan");
  SplitLogCounters.resetCounters();
  final ServerName SRV = ServerName.valueOf("svr,1,1");
  RegionServerServices mockedRS = getRegionServer(SRV);
  slw = new SplitLogWorker(ds, TEST_UTIL.getConfiguration(), mockedRS, neverEndingTask);
  slw.start();
  Thread.yield(); // let the worker start
  Thread.sleep(100);

  String task = ZKSplitLog.getEncodedNodeName(zkw, "task");
  SplitLogTask slt = new SplitLogTask.Unassigned(MANAGER);
  zkw.getRecoverableZooKeeper().create(task,slt.toByteArray(), Ids.OPEN_ACL_UNSAFE,
    CreateMode.PERSISTENT);

  waitForCounter(SplitLogCounters.tot_wkr_task_acquired, 0, 1, WAIT_TIME);
  // now the worker is busy doing the above task

  // preempt the task, have it owned by another worker
  ZKUtil.setData(zkw, task, slt.toByteArray());
  waitForCounter(SplitLogCounters.tot_wkr_preempt_task, 0, 1, WAIT_TIME);

  // create a RESCAN node
  String rescan = ZKSplitLog.getEncodedNodeName(zkw, "RESCAN");
  rescan = zkw.getRecoverableZooKeeper().create(rescan, slt.toByteArray(), Ids.OPEN_ACL_UNSAFE,
    CreateMode.PERSISTENT_SEQUENTIAL);

  waitForCounter(SplitLogCounters.tot_wkr_task_acquired, 1, 2, WAIT_TIME);
  // RESCAN node might not have been processed if the worker became busy
  // with the above task. preempt the task again so that now the RESCAN
  // node is processed
  ZKUtil.setData(zkw, task, slt.toByteArray());
  waitForCounter(SplitLogCounters.tot_wkr_preempt_task, 1, 2, WAIT_TIME);
  waitForCounter(SplitLogCounters.tot_wkr_task_acquired_rescan, 0, 1, WAIT_TIME);

  List<String> nodes = ZKUtil.listChildrenNoWatch(zkw, zkw.znodePaths.splitLogZNode);
  LOG.debug(Objects.toString(nodes));
  int num = 0;
  for (String node : nodes) {
    num++;
    if (node.startsWith("RESCAN")) {
      String name = ZKSplitLog.getEncodedNodeName(zkw, node);
      String fn = ZKSplitLog.getFileName(name);
      byte [] data = ZKUtil.getData(zkw, ZNodePaths.joinZNode(zkw.znodePaths.splitLogZNode, fn));
      slt = SplitLogTask.parseFrom(data);
      assertTrue(slt.toString(), slt.isDone(SRV));
    }
  }
  assertEquals(2, num);
}
 

import org.apache.hadoop.hbase.zookeeper.ZKSplitLog; //导入方法依赖的package包/类
@Test
public void testRescan() throws Exception {
  LOG.info("testRescan");
  SplitLogCounters.resetCounters();
  final ServerName SRV = ServerName.valueOf("svr,1,1");
  RegionServerServices mockedRS = getRegionServer(SRV);
  slw = new SplitLogWorker(zkw, TEST_UTIL.getConfiguration(), mockedRS, neverEndingTask);
  slw.start();
  Thread.yield(); // let the worker start
  Thread.sleep(100);

  String task = ZKSplitLog.getEncodedNodeName(zkw, "task");
  SplitLogTask slt = new SplitLogTask.Unassigned(MANAGER);
  zkw.getRecoverableZooKeeper().create(task,slt.toByteArray(), Ids.OPEN_ACL_UNSAFE,
    CreateMode.PERSISTENT);

  waitForCounter(SplitLogCounters.tot_wkr_task_acquired, 0, 1, 1500);
  // now the worker is busy doing the above task

  // preempt the task, have it owned by another worker
  ZKUtil.setData(zkw, task, slt.toByteArray());
  waitForCounter(SplitLogCounters.tot_wkr_preempt_task, 0, 1, 1500);

  // create a RESCAN node
  String rescan = ZKSplitLog.getEncodedNodeName(zkw, "RESCAN");
  rescan = zkw.getRecoverableZooKeeper().create(rescan, slt.toByteArray(), Ids.OPEN_ACL_UNSAFE,
    CreateMode.PERSISTENT_SEQUENTIAL);

  waitForCounter(SplitLogCounters.tot_wkr_task_acquired, 1, 2, 1500);
  // RESCAN node might not have been processed if the worker became busy
  // with the above task. preempt the task again so that now the RESCAN
  // node is processed
  ZKUtil.setData(zkw, task, slt.toByteArray());
  waitForCounter(SplitLogCounters.tot_wkr_preempt_task, 1, 2, 1500);
  waitForCounter(SplitLogCounters.tot_wkr_task_acquired_rescan, 0, 1, 1500);

  List<String> nodes = ZKUtil.listChildrenNoWatch(zkw, zkw.splitLogZNode);
  LOG.debug(nodes);
  int num = 0;
  for (String node : nodes) {
    num++;
    if (node.startsWith("RESCAN")) {
      String name = ZKSplitLog.getEncodedNodeName(zkw, node);
      String fn = ZKSplitLog.getFileName(name);
      byte [] data = ZKUtil.getData(zkw, ZKUtil.joinZNode(zkw.splitLogZNode, fn));
      slt = SplitLogTask.parseFrom(data);
      assertTrue(slt.toString(), slt.isDone(SRV));
    }
  }
  assertEquals(2, num);
}