org.I0Itec.zkclient.exception.ZkNoNodeException Java Examples

/**
 * Create a persistent Sequential node.
 *
 * @param path
 * @param data
 * @param createParents if true all parent dirs are created as well and no
 * {@link ZkNodeExistsException} is thrown in case the path already exists
 * @throws ZkInterruptedException if operation was interrupted, or a
 * required reconnection got interrupted
 * @throws IllegalArgumentException if called from anything except the
 * ZooKeeper event thread
 * @throws ZkException if any ZooKeeper exception occurred
 * @throws RuntimeException if any other exception occurs
 */
public String createPersistentSequential(String path, Object data, boolean createParents)
                                                                                         throws ZkInterruptedException,
                                                                                         IllegalArgumentException,
                                                                                         ZkException,
                                                                                         RuntimeException {
    try {
        return create(path, data, CreateMode.PERSISTENT_SEQUENTIAL);
    } catch (ZkNoNodeException e) {
        if (!createParents) {
            throw e;
        }
        String parentDir = path.substring(0, path.lastIndexOf('/'));
        createPersistent(parentDir, createParents);
        return createPersistentSequential(path, data, createParents);
    }
}
 

private void fireDataChangedEvents(final String path, Set<IZkDataListener> listeners) {
    for (final IZkDataListener listener : listeners) {
        _eventThread.send(new ZkEventThread.ZkEvent("Data of " + path + " changed sent to " + listener) {

            @Override
            public void run() throws Exception {
                // reinstall watch
                exists(path, true);
                Stat stat = new Stat();
                try {
                    Object data = readData(path, stat, true);
                    listener.handleDataChange(path, data, stat);
                } catch (ZkNoNodeException e) {
                    listener.handleDataDeleted(path);
                }
            }
        });
    }
}
 

public boolean deleteRecursive(String path) {
    List<String> children;
    try {
        children = getChildren(path, false);
    } catch (ZkNoNodeException e) {
        return true;
    }

    for (String subPath : children) {
        if (!deleteRecursive(path + "/" + subPath)) {
            return false;
        }
    }

    return delete(path);
}
 

@Override
public boolean delete(final String path) {
  long startT = System.nanoTime();
  try {
    try {
      retryUntilConnected(() -> {
        _connection.delete(path);
        return null;
      });

      return true;
    } catch (ZkNoNodeException e) {
      return false;
    }
  } finally {
    long endT = System.nanoTime();
    if (LOG.isTraceEnabled()) {
      LOG.trace("delete, path: {}, time: {} ns", path, (endT - startT));
    }
  }
}
 

/**
 * Given an instance name and a datastream task name assigned to this instance, return
 * a desrialized DatastreamTask object from its JSON serialized definition in ZooKeeper.
 * @return DatastreamTask instance for the specified task name OR null if task node
 *         does not exist or is inaccessible
 */
public DatastreamTaskImpl getAssignedDatastreamTask(String instance, String taskName) {
  try {
    String content = _zkclient.ensureReadData(KeyBuilder.instanceAssignment(_cluster, instance, taskName));
    DatastreamTaskImpl task = DatastreamTaskImpl.fromJson(content);
    if (Strings.isNullOrEmpty(task.getTaskPrefix())) {
      task.setTaskPrefix(parseTaskPrefix(task.getDatastreamTaskName()));
    }

    if (Strings.isNullOrEmpty(task.getTransportProviderName())) {
      task.setTransportProviderName(_defaultTransportProviderName);
    }

    task.setZkAdapter(this);
    return task;
  } catch (ZkNoNodeException e) {
    // This can occur if there is another task assignment change in the middle of
    // handleAssignmentChange and some tasks are unassigned to the current
    // instance. In this case, we would get such exception. This is tolerable
    // because we should be receiving another AssignmentChange event right after
    // then we can dispatch the tasks based on the latest assignment data.
    LOG.warn("ZNode does not exist for instance={}, task={}, ignoring the task.", instance, taskName);
    return null;
  }
}
 

/**
 * Lookup the datastream based on its name from ZK.
 * @param datastreamName name of the datastream
 * @return the datastream object if exists; or null not exists in ZK
 */
private Datastream getDatastreamFromZk(String datastreamName) {
  String path = KeyBuilder.datastream(_cluster, datastreamName);
  if (_zkclient.exists(path)) {
    try {
      String content = _zkclient.ensureReadData(path);
      if (content != null) {
        return DatastreamUtils.fromJSON(content);
      }
    } catch (ZkNoNodeException e) {
      // This can happen when the path still exists but later deleted
      // during ensureReadData
      LOG.warn("Datastream {} is just deleted from ZK.", datastreamName);
    }
  }
  return null;
}
 

public boolean delete(final String path, final int version) {
    try {
        retryUntilConnected(new Callable<Object>() {

            @Override
            public Object call() throws Exception {
                _connection.delete(path, version);
                return null;
            }
        });

        return true;
    } catch (ZkNoNodeException e) {
        return false;
    }
}
 

@Override
public Zk delete(String path, int version, Handler<AsyncResult<Void>> handler) {
    workerPool().executeBlocking(
        future -> {
            try {
                if (zookeeper.delete(path, version)) {
                    future.complete();
                } else {
                    future.fail(new ZkNoNodeException());
                }
            } catch (Throwable t) {
                future.fail(t);
            }
        },
        handler);
    return this;
}
 

/**
 * Create a persistent Sequential node.
 *
 * @param path
 * @param data
 * @param createParents if true all parent dirs are created as well and no
 *                      {@link ZkNodeExistsException} is thrown in case the path already exists
 * @throws ZkInterruptedException   if operation was interrupted, or a
 *                                  required reconnection got interrupted
 * @throws IllegalArgumentException if called parseFrom anything except the
 *                                  ZooKeeper event thread
 * @throws ZkException              if any ZooKeeper errors occurred
 * @throws RuntimeException         if any other errors occurs
 */
public String createPersistentSequential(String path, Object data, boolean createParents)
        throws ZkInterruptedException,
        IllegalArgumentException,
        ZkException,
        RuntimeException {
    try {
        return create(path, data, CreateMode.PERSISTENT_SEQUENTIAL);
    } catch (ZkNoNodeException e) {
        if (!createParents) {
            throw e;
        }
        String parentDir = path.substring(0, path.lastIndexOf('/'));
        createPersistent(parentDir, createParents);
        return createPersistentSequential(path, data, createParents);
    }
}
 

/**
 * Installs a child watch for the given path.
 *
 * @param path
 * @return the current children of the path or null if the zk node with the given path doesn't exist.
 */
public List<String> watchForChilds(final String path) {
    if (_zookeeperEventThread != null && Thread.currentThread() == _zookeeperEventThread) {
        throw new IllegalArgumentException("Must not be done in the zookeeper event thread.");
    }
    return retryUntilConnected(new Callable<List<String>>() {
        @Override
        public List<String> call() throws Exception {
            exists(path, true);
            try {
                return getChildren(path, true);
            } catch (ZkNoNodeException e) {
                // ignore, the "exists" watch will listen for the parent node to appear
            }
            return null;
        }
    });
}
 

/**
 * Create a persistent Sequential node.
 *
 * @param path
 * @param data
 * @param createParents if true all parent dirs are created as well and no
 * {@link ZkNodeExistsException} is thrown in case the path already exists
 * @throws ZkInterruptedException if operation was interrupted, or a
 * required reconnection got interrupted
 * @throws IllegalArgumentException if called from anything except the
 * ZooKeeper event thread
 * @throws ZkException if any ZooKeeper exception occurred
 * @throws RuntimeException if any other exception occurs
 */
public String createPersistentSequential(String path, Object data, boolean createParents)
                                                                                         throws ZkInterruptedException,
                                                                                         IllegalArgumentException,
                                                                                         ZkException,
                                                                                         RuntimeException {
    try {
        return create(path, data, CreateMode.PERSISTENT_SEQUENTIAL);
    } catch (ZkNoNodeException e) {
        if (!createParents) {
            throw e;
        }
        String parentDir = path.substring(0, path.lastIndexOf('/'));
        createPersistent(parentDir, createParents);
        return createPersistentSequential(path, data, createParents);
    }
}
 

@Override
public Future<Topic> read(TopicName topicName) {
    Promise<Topic> handler = Promise.promise();
    String topicPath = getTopicPath(topicName);
    zk.getData(topicPath, result -> {
        final AsyncResult<Topic> fut;
        if (result.succeeded()) {
            fut = Future.succeededFuture(TopicSerialization.fromJson(result.result()));
        } else {
            if (result.cause() instanceof ZkNoNodeException) {
                fut = Future.succeededFuture(null);
            } else {
                fut = result.map((Topic) null);
            }
        }
        handler.handle(fut);
    });
    return handler.future();
}
 

public PositionRange getLastestBatch(ClientIdentity clientIdentity) {
    String path = ZookeeperPathUtils.getBatchMarkPath(clientIdentity.getDestination(),
        clientIdentity.getClientId());
    List<String> nodes = null;
    try {
        nodes = zkClientx.getChildren(path);
    } catch (ZkNoNodeException e) {
        // ignore
    }

    if (CollectionUtils.isEmpty(nodes)) {
        return null;
    }
    // 找到最大的Id
    ArrayList<Long> batchIds = new ArrayList<Long>(nodes.size());
    for (String batchIdString : nodes) {
        batchIds.add(Long.valueOf(batchIdString));
    }
    Long maxBatchId = Collections.max(batchIds);
    PositionRange result = getBatch(clientIdentity, maxBatchId);
    if (result == null) { // 出现为null，说明zk节点有变化，重新获取
        return getLastestBatch(clientIdentity);
    } else {
        return result;
    }
}
 

public PositionRange getFirstBatch(ClientIdentity clientIdentity) {
    String path = ZookeeperPathUtils.getBatchMarkPath(clientIdentity.getDestination(),
        clientIdentity.getClientId());
    List<String> nodes = null;
    try {
        nodes = zkClientx.getChildren(path);
    } catch (ZkNoNodeException e) {
        // ignore
    }

    if (CollectionUtils.isEmpty(nodes)) {
        return null;
    }
    // 找到最小的Id
    ArrayList<Long> batchIds = new ArrayList<Long>(nodes.size());
    for (String batchIdString : nodes) {
        batchIds.add(Long.valueOf(batchIdString));
    }
    Long minBatchId = Collections.min(batchIds);
    PositionRange result = getBatch(clientIdentity, minBatchId);
    if (result == null) { // 出现为null，说明zk节点有变化，重新获取
        return getFirstBatch(clientIdentity);
    } else {
        return result;
    }
}
 

public PositionRange getLastestBatch(ClientIdentity clientIdentity) {
    String path = ZookeeperPathUtils.getBatchMarkPath(clientIdentity.getDestination(),
        clientIdentity.getClientId());
    List<String> nodes = null;
    try {
        nodes = zkClientx.getChildren(path);
    } catch (ZkNoNodeException e) {
        // ignore
    }

    if (CollectionUtils.isEmpty(nodes)) {
        return null;
    }
    // 找到最大的Id
    ArrayList<Long> batchIds = new ArrayList<Long>(nodes.size());
    for (String batchIdString : nodes) {
        batchIds.add(Long.valueOf(batchIdString));
    }
    Long maxBatchId = Collections.max(batchIds);
    PositionRange result = getBatch(clientIdentity, maxBatchId);
    if (result == null) { // 出现为null，说明zk节点有变化，重新获取
        return getLastestBatch(clientIdentity);
    } else {
        return result;
    }
}
 

public PositionRange getFirstBatch(ClientIdentity clientIdentity) {
    String path = ZookeeperPathUtils.getBatchMarkPath(clientIdentity.getDestination(),
        clientIdentity.getClientId());
    List<String> nodes = null;
    try {
        nodes = zkClientx.getChildren(path);
    } catch (ZkNoNodeException e) {
        // ignore
    }

    if (CollectionUtils.isEmpty(nodes)) {
        return null;
    }
    // 找到最小的Id
    ArrayList<Long> batchIds = new ArrayList<Long>(nodes.size());
    for (String batchIdString : nodes) {
        batchIds.add(Long.valueOf(batchIdString));
    }
    Long minBatchId = Collections.min(batchIds);
    PositionRange result = getBatch(clientIdentity, minBatchId);
    if (result == null) { // 出现为null，说明zk节点有变化，重新获取
        return getFirstBatch(clientIdentity);
    } else {
        return result;
    }
}
 

/**
 * Installs a child watch for the given path.
 *
 * @param path
 * @return the current children of the path or null if the zk node with the given path doesn't exist.
 */
public List<String> watchForChilds(final String path) {
    if (_zookeeperEventThread != null && Thread.currentThread() == _zookeeperEventThread) {
        throw new IllegalArgumentException("Must not be done in the zookeeper event thread.");
    }
    return retryUntilConnected(new Callable<List<String>>() {
        @Override
        public List<String> call() throws Exception {
            exists(path, true);
            try {
                return getChildren(path, true);
            } catch (ZkNoNodeException e) {
                // ignore, the "exists" watch will listen for the parent node to appear
            }
            return null;
        }
    });
}
 

public boolean delete(final String path, final int version) {
    try {
        retryUntilConnected(new Callable<Object>() {

            @Override
            public Object call() throws Exception {
                _connection.delete(path, version);
                return null;
            }
        });

        return true;
    } catch (ZkNoNodeException e) {
        return false;
    }
}
 

private void fireDataChangedEvents(final String path, Set<IZkDataListener> listeners) {
    for (final IZkDataListener listener : listeners) {
        _eventThread.send(new ZkEventThread.ZkEvent("Data of " + path + " changed sent to " + listener) {

            @Override
            public void run() throws Exception {
                // reinstall watch
                exists(path, true);
                Stat stat = new Stat();
                try {
                    Object data = readData(path, stat, true);
                    listener.handleDataChange(path, data, stat);
                } catch (ZkNoNodeException e) {
                    listener.handleDataDeleted(path);
                }
            }
        });
    }
}
 

public boolean deleteRecursive(String path) {
    List<String> children;
    try {
        children = getChildren(path, false);
    } catch (ZkNoNodeException e) {
        return true;
    }

    for (String subPath : children) {
        if (!deleteRecursive(path + "/" + subPath)) {
            return false;
        }
    }

    return delete(path);
}
 

@VisibleForTesting
List<String> getChildrenParentMayNotExist(String path) {
    try {
        return client.getChildren(path);
    } catch (final ZkNoNodeException e) {
        return Lists.newArrayList();
    }
}
 

public Map<Long, PositionRange> listAllBatchs(ClientIdentity clientIdentity) {
    String path = ZookeeperPathUtils.getBatchMarkPath(clientIdentity.getDestination(),
        clientIdentity.getClientId());
    List<String> nodes = null;
    try {
        nodes = zkClientx.getChildren(path);
    } catch (ZkNoNodeException e) {
        // ignore
    }

    if (CollectionUtils.isEmpty(nodes)) {
        return Maps.newHashMap();
    }
    // 找到最大的Id
    ArrayList<Long> batchIds = new ArrayList<Long>(nodes.size());
    for (String batchIdString : nodes) {
        batchIds.add(Long.valueOf(batchIdString));
    }

    Collections.sort(batchIds); // 从小到大排序
    Map<Long, PositionRange> positionRanges = Maps.newLinkedHashMap();
    for (Long batchId : batchIds) {
        PositionRange result = getBatch(clientIdentity, batchId);
        if (result == null) {// 出现为null，说明zk节点有变化，重新获取
            return listAllBatchs(clientIdentity);
        } else {
            positionRanges.put(batchId, result);
        }
    }

    return positionRanges;
}
 

public void updateCursor(ClientIdentity clientIdentity, Position position) throws CanalMetaManagerException {
    String path = ZookeeperPathUtils.getCursorPath(clientIdentity.getDestination(), clientIdentity.getClientId());
    byte[] data = JsonUtils.marshalToByte(position, SerializerFeature.WriteClassName);
    try {
        zkClientx.writeData(path, data);
    } catch (ZkNoNodeException e) {
        zkClientx.createPersistent(path, data, true);// 第一次节点不存在，则尝试重建
    }
}
 

@Override
public void persistLogPosition(String destination, LogPosition logPosition) throws CanalParseException {
    String path = ZookeeperPathUtils.getParsePath(destination);
    byte[] data = JsonUtils.marshalToByte(logPosition);
    try {
        zkClientx.writeData(path, data);
    } catch (ZkNoNodeException e) {
        zkClientx.createPersistent(path, data, true);
    }
}
 

private Tuple2<String, Stat> readZkData(String path) {
	Tuple2<String, Stat> offset_stat = null;
	try {
		offset_stat = ZKUtils.getZKUtilsFromKafka().readData(path);
	} catch (ZkNoNodeException znne) {
		// TODO no offset record in zk?
	}
	return offset_stat;
}
 

public List<String> getChildren(String path) {
    try {
        return client.getChildren(path);
    } catch (ZkNoNodeException e) {
        return null;
    }
}
 

/**
    * 创建一个持久的顺序节点
    */
public String createPersistentSequential(String path, boolean createParents)
		throws ZkInterruptedException, IllegalArgumentException, ZkException, RuntimeException {
       try {
           return create(path, null, CreateMode.PERSISTENT_SEQUENTIAL);
       } catch (ZkNoNodeException e) {
           if (!createParents) {
               throw e;
           }
           String parentDir = path.substring(0, path.lastIndexOf('/'));
           createPersistent(parentDir, createParents);
           return createPersistentSequential(path, createParents);
       }
   }
 

public String createPersistentSequential(String path, Object data, boolean createParents)
throws ZkInterruptedException, IllegalArgumentException, ZkException, RuntimeException {
     try {
         return create(path, data, CreateMode.PERSISTENT_SEQUENTIAL);
     } catch (ZkNoNodeException e) {
         if (!createParents) {
             throw e;
         }
         String parentDir = path.substring(0, path.lastIndexOf('/'));
         createPersistent(parentDir, createParents);
         return createPersistentSequential(path, data, createParents);
     }
 }
 

@Override
public Future<Void> delete(TopicName topicName) {
    Promise<Void> handler = Promise.promise();
    // TODO pass a non-zero version
    String topicPath = getTopicPath(topicName);
    LOGGER.debug("delete znode {}", topicPath);
    zk.delete(topicPath, -1, result -> {
        if (result.failed() && result.cause() instanceof ZkNoNodeException) {
            handler.handle(Future.failedFuture(new NoSuchEntityExistsException()));
        } else {
            handler.handle(result);
        }
    });
    return handler.future();
}
 

public List<String> getChildren(String path) {
	try {
		return client.getChildren(path);
       } catch (ZkNoNodeException e) {
           return null;
       }
}