Java ZKSplitLog.isRescanNode方法代码示例

import org.apache.hadoop.hbase.zookeeper.ZKSplitLog; //导入方法依赖的package包/类
@Override
public int remainingTasksInCoordination() {
  int count = 0;
  try {
    List<String> tasks = ZKUtil.listChildrenNoWatch(watcher, watcher.splitLogZNode);
    if (tasks != null) {
      int listSize = tasks.size();
      for (int i = 0; i < listSize; i++) {
        if (!ZKSplitLog.isRescanNode(tasks.get(i))) {
          count++;
        }
      }
    }
  } catch (KeeperException ke) {
    LOG.warn("Failed to check remaining tasks", ke);
    count = -1;
  }
  return count;
}
 

import org.apache.hadoop.hbase.zookeeper.ZKSplitLog; //导入方法依赖的package包/类
private void deleteNodeSuccess(String path) {
  if (ignoreZKDeleteForTesting) {
    return;
  }
  Task task;
  task = details.getTasks().remove(path);
  if (task == null) {
    if (ZKSplitLog.isRescanNode(watcher, path)) {
      SplitLogCounters.tot_mgr_rescan_deleted.incrementAndGet();
    }
    SplitLogCounters.tot_mgr_missing_state_in_delete.incrementAndGet();
    LOG.debug("deleted task without in memory state " + path);
    return;
  }
  synchronized (task) {
    task.status = DELETED;
    task.notify();
  }
  SplitLogCounters.tot_mgr_task_deleted.incrementAndGet();
}
 

import org.apache.hadoop.hbase.zookeeper.ZKSplitLog; //导入方法依赖的package包/类
private int remainingTasksInZK() {
  int count = 0;
  try {
    List<String> tasks =
      ZKUtil.listChildrenNoWatch(watcher, watcher.splitLogZNode);
    if (tasks != null) {
      for (String t: tasks) {
        if (!ZKSplitLog.isRescanNode(watcher, t)) {
          count++;
        }
      }
    }
  } catch (KeeperException ke) {
    LOG.warn("Failed to check remaining tasks", ke);
    count = -1;
  }
  return count;
}
 

import org.apache.hadoop.hbase.zookeeper.ZKSplitLog; //导入方法依赖的package包/类
private void deleteNodeSuccess(String path) {
  if (ignoreZKDeleteForTesting) {
    return;
  }
  Task task;
  task = tasks.remove(path);
  if (task == null) {
    if (ZKSplitLog.isRescanNode(watcher, path)) {
      tot_mgr_rescan_deleted.incrementAndGet();
    }
    tot_mgr_missing_state_in_delete.incrementAndGet();
    LOG.debug("deleted task without in memory state " + path);
    return;
  }
  synchronized (task) {
    task.status = DELETED;
    task.notify();
  }
  tot_mgr_task_deleted.incrementAndGet();
}
 

import org.apache.hadoop.hbase.zookeeper.ZKSplitLog; //导入方法依赖的package包/类
@Override
public int remainingTasksInCoordination() {
  int count = 0;
  try {
    List<String> tasks = ZKUtil.listChildrenNoWatch(watcher, watcher.splitLogZNode);
    if (tasks != null) {
      int listSize = tasks.size();
      for (int i = 0; i < listSize; i++) {
        if (!ZKSplitLog.isRescanNode(watcher, tasks.get(i))) {
          count++;
        }
      }
    }
  } catch (KeeperException ke) {
    LOG.warn("Failed to check remaining tasks", ke);
    count = -1;
  }
  return count;
}
 

import org.apache.hadoop.hbase.zookeeper.ZKSplitLog; //导入方法依赖的package包/类
private void deleteNodeSuccess(String path) {
  if (ignoreZKDeleteForTesting) {
    return;
  }
  Task task;
  task = tasks.remove(path);
  if (task == null) {
    if (ZKSplitLog.isRescanNode(watcher, path)) {
      SplitLogCounters.tot_mgr_rescan_deleted.incrementAndGet();
    }
    SplitLogCounters.tot_mgr_missing_state_in_delete.incrementAndGet();
    LOG.debug("deleted task without in memory state " + path);
    return;
  }
  synchronized (task) {
    task.status = DELETED;
    task.notify();
  }
  SplitLogCounters.tot_mgr_task_deleted.incrementAndGet();
}
 

import org.apache.hadoop.hbase.zookeeper.ZKSplitLog; //导入方法依赖的package包/类
@Override
public int remainingTasksInCoordination() {
  int count = 0;
  try {
    List<String> tasks = ZKUtil.listChildrenNoWatch(watcher, watcher.znodePaths.splitLogZNode);
    if (tasks != null) {
      int listSize = tasks.size();
      for (int i = 0; i < listSize; i++) {
        if (!ZKSplitLog.isRescanNode(tasks.get(i))) {
          count++;
        }
      }
    }
  } catch (KeeperException ke) {
    LOG.warn("Failed to check remaining tasks", ke);
    count = -1;
  }
  return count;
}
 

import org.apache.hadoop.hbase.zookeeper.ZKSplitLog; //导入方法依赖的package包/类
private void deleteNodeSuccess(String path) {
  if (ignoreZKDeleteForTesting) {
    return;
  }
  Task task;
  task = details.getTasks().remove(path);
  if (task == null) {
    if (ZKSplitLog.isRescanNode(watcher, path)) {
      SplitLogCounters.tot_mgr_rescan_deleted.increment();
    }
    SplitLogCounters.tot_mgr_missing_state_in_delete.increment();
    LOG.debug("Deleted task without in memory state " + path);
    return;
  }
  synchronized (task) {
    task.status = DELETED;
    task.notify();
  }
  SplitLogCounters.tot_mgr_task_deleted.increment();
}
 

import org.apache.hadoop.hbase.zookeeper.ZKSplitLog; //导入方法依赖的package包/类
/**
 * It is possible for a task to stay in UNASSIGNED state indefinitely - say SplitLogManager wants
 * to resubmit a task. It forces the task to UNASSIGNED state but it dies before it could create
 * the RESCAN task node to signal the SplitLogWorkers to pick up the task. To prevent this
 * scenario the SplitLogManager resubmits all orphan and UNASSIGNED tasks at startup.
 * @param path
 */
private void handleUnassignedTask(String path) {
  if (ZKSplitLog.isRescanNode(watcher, path)) {
    return;
  }
  Task task = findOrCreateOrphanTask(path);
  if (task.isOrphan() && (task.incarnation.get() == 0)) {
    LOG.info("resubmitting unassigned orphan task " + path);
    // ignore failure to resubmit. The timeout-monitor will handle it later
    // albeit in a more crude fashion
    resubmitTask(path, task, FORCE);
  }
}
 

import org.apache.hadoop.hbase.zookeeper.ZKSplitLog; //导入方法依赖的package包/类
private void setDone(String path, TerminationStatus status) {
  Task task = details.getTasks().get(path);
  if (task == null) {
    if (!ZKSplitLog.isRescanNode(watcher, path)) {
      SplitLogCounters.tot_mgr_unacquired_orphan_done.incrementAndGet();
      LOG.debug("unacquired orphan task is done " + path);
    }
  } else {
    synchronized (task) {
      if (task.status == IN_PROGRESS) {
        if (status == SUCCESS) {
          SplitLogCounters.tot_mgr_log_split_success.incrementAndGet();
          LOG.info("Done splitting " + path);
        } else {
          SplitLogCounters.tot_mgr_log_split_err.incrementAndGet();
          LOG.warn("Error splitting " + path);
        }
        task.status = status;
        if (task.batch != null) {
          synchronized (task.batch) {
            if (status == SUCCESS) {
              task.batch.done++;
            } else {
              task.batch.error++;
            }
            task.batch.notify();
          }
        }
      }
    }
  }
  // delete the task node in zk. It's an async
  // call and no one is blocked waiting for this node to be deleted. All
  // task names are unique (log.<timestamp>) there is no risk of deleting
  // a future task.
  // if a deletion fails, TimeoutMonitor will retry the same deletion later
  deleteNode(path, zkretries);
  return;
}
 

import org.apache.hadoop.hbase.zookeeper.ZKSplitLog; //导入方法依赖的package包/类
private void lookForOrphans() {
  List<String> orphans;
  try {
    orphans = ZKUtil.listChildrenNoWatch(this.watcher, this.watcher.splitLogZNode);
    if (orphans == null) {
      LOG.warn("could not get children of " + this.watcher.splitLogZNode);
      return;
    }
  } catch (KeeperException e) {
    LOG.warn("could not get children of " + this.watcher.splitLogZNode + " "
        + StringUtils.stringifyException(e));
    return;
  }
  int rescan_nodes = 0;
  int listSize = orphans.size();
  for (int i = 0; i < listSize; i++) {
    String path = orphans.get(i);
    String nodepath = ZKUtil.joinZNode(watcher.splitLogZNode, path);
    if (ZKSplitLog.isRescanNode(watcher, nodepath)) {
      rescan_nodes++;
      LOG.debug("found orphan rescan node " + path);
    } else {
      LOG.info("found orphan task " + path);
    }
    getDataSetWatch(nodepath, zkretries);
  }
  LOG.info("Found " + (orphans.size() - rescan_nodes) + " orphan tasks and " + rescan_nodes
      + " rescan nodes");
}
 

import org.apache.hadoop.hbase.zookeeper.ZKSplitLog; //导入方法依赖的package包/类
@Override
public void nodeDataChanged(String path) {
  Task task;
  task = details.getTasks().get(path);
  if (task != null || ZKSplitLog.isRescanNode(watcher, path)) {
    if (task != null) {
      task.heartbeatNoDetails(EnvironmentEdgeManager.currentTime());
    }
    getDataSetWatch(path, zkretries);
  }
}
 

import org.apache.hadoop.hbase.zookeeper.ZKSplitLog; //导入方法依赖的package包/类
private List<String> listSplitLogTasks() throws KeeperException {
  List<String> taskOrRescanList = ZKUtil.listChildrenNoWatch(watcher, watcher.splitLogZNode);
  if (taskOrRescanList == null || taskOrRescanList.isEmpty()) {
    return Collections.<String> emptyList();
  }
  List<String> taskList = new ArrayList<String>();
  for (String taskOrRescan : taskOrRescanList) {
    // Remove rescan nodes
    if (!ZKSplitLog.isRescanNode(taskOrRescan)) {
      taskList.add(taskOrRescan);
    }
  }
  return taskList;
}
 

import org.apache.hadoop.hbase.zookeeper.ZKSplitLog; //导入方法依赖的package包/类
private void setDone(String path, TerminationStatus status) {
  Task task = tasks.get(path);
  if (task == null) {
    if (!ZKSplitLog.isRescanNode(watcher, path)) {
      tot_mgr_unacquired_orphan_done.incrementAndGet();
      LOG.debug("unacquired orphan task is done " + path);
    }
  } else {
    synchronized (task) {
      if (task.status == IN_PROGRESS) {
        if (status == SUCCESS) {
          tot_mgr_log_split_success.incrementAndGet();
          LOG.info("Done splitting " + path);
        } else {
          tot_mgr_log_split_err.incrementAndGet();
          LOG.warn("Error splitting " + path);
        }
        task.status = status;
        if (task.batch != null) {
          synchronized (task.batch) {
            if (status == SUCCESS) {
              task.batch.done++;
            } else {
              task.batch.error++;
            }
            task.batch.notify();
          }
        }
      }
    }
  }
  // delete the task node in zk. It's an async
  // call and no one is blocked waiting for this node to be deleted. All
  // task names are unique (log.<timestamp>) there is no risk of deleting
  // a future task.
  // if a deletion fails, TimeoutMonitor will retry the same deletion later
  deleteNode(path, zkretries);
  return;
}
 

import org.apache.hadoop.hbase.zookeeper.ZKSplitLog; //导入方法依赖的package包/类
/**
 * It is possible for a task to stay in UNASSIGNED state indefinitely - say
 * SplitLogManager wants to resubmit a task. It forces the task to UNASSIGNED
 * state but it dies before it could create the RESCAN task node to signal
 * the SplitLogWorkers to pick up the task. To prevent this scenario the
 * SplitLogManager resubmits all orphan and UNASSIGNED tasks at startup.
 *
 * @param path
 */
private void handleUnassignedTask(String path) {
  if (ZKSplitLog.isRescanNode(watcher, path)) {
    return;
  }
  Task task = findOrCreateOrphanTask(path);
  if (task.isOrphan() && (task.incarnation == 0)) {
    LOG.info("resubmitting unassigned orphan task " + path);
    // ignore failure to resubmit. The timeout-monitor will handle it later
    // albeit in a more crude fashion
    resubmit(path, task, FORCE);
  }
}