java类org.apache.zookeeper.proto.DeleteRequest的实例源码

/**
 * Delete the node with the given path. The call will succeed if such a node
 * exists, and the given version matches the node's version (if the given
 * version is -1, it matches any node's versions).
 * <p>
 * A KeeperException with error code KeeperException.NoNode will be thrown
 * if the nodes does not exist.
 * <p>
 * A KeeperException with error code KeeperException.BadVersion will be
 * thrown if the given version does not match the node's version.
 * <p>
 * A KeeperException with error code KeeperException.NotEmpty will be thrown
 * if the node has children.
 * <p>
 * This operation, if successful, will trigger all the watches on the node
 * of the given path left by exists API calls, and the watches on the parent
 * node left by getChildren API calls.
 *
 * @param path
 *                the path of the node to be deleted.
 * @param version
 *                the expected node version.
 * @throws InterruptedException IF the server transaction is interrupted
 * @throws KeeperException If the server signals an error with a non-zero
 *   return code.
 * @throws IllegalArgumentException if an invalid path is specified
 */
public void delete(final String path, int version)
    throws InterruptedException, KeeperException
{
    final String clientPath = path;
    PathUtils.validatePath(clientPath);

    final String serverPath;

    // maintain semantics even in chroot case
    // specifically - root cannot be deleted
    // I think this makes sense even in chroot case.
    if (clientPath.equals("/")) {
        // a bit of a hack, but delete(/) will never succeed and ensures
        // that the same semantics are maintained
        serverPath = clientPath;
    } else {
        serverPath = prependChroot(clientPath);
    }

    RequestHeader h = new RequestHeader();
    h.setType(ZooDefs.OpCode.delete);
    DeleteRequest request = new DeleteRequest();
    request.setPath(serverPath);
    request.setVersion(version);
    ReplyHeader r = cnxn.submitRequest(h, request, null, null);
    if (r.getErr() != 0) {
        throw KeeperException.create(KeeperException.Code.get(r.getErr()),
                clientPath);
    }
}

/**
 * The asynchronous version of delete.
 *
 * @see #delete(String, int)
 */
public void delete(final String path, int version, VoidCallback cb,
        Object ctx)
{
    final String clientPath = path;
    PathUtils.validatePath(clientPath);

    final String serverPath;

    // maintain semantics even in chroot case
    // specifically - root cannot be deleted
    // I think this makes sense even in chroot case.
    if (clientPath.equals("/")) {
        // a bit of a hack, but delete(/) will never succeed and ensures
        // that the same semantics are maintained
        serverPath = clientPath;
    } else {
        serverPath = prependChroot(clientPath);
    }

    RequestHeader h = new RequestHeader();
    h.setType(ZooDefs.OpCode.delete);
    DeleteRequest request = new DeleteRequest();
    request.setPath(serverPath);
    request.setVersion(version);
    cnxn.queuePacket(h, new ReplyHeader(), request, null, cb, clientPath,
            serverPath, ctx, null);
}

private static void deleteNodeFailSilent(ZooKeeperWatcher zkw,
    DeleteNodeFailSilent dnfs) throws KeeperException {
  DeleteRequest delete = (DeleteRequest)toZooKeeperOp(zkw, dnfs).toRequestRecord();
  try {
    zkw.getRecoverableZooKeeper().delete(delete.getPath(), delete.getVersion());
  } catch(KeeperException.NoNodeException nne) {
  } catch(InterruptedException ie) {
    zkw.interruptedException(ie);
  }
}

/**
 * Delete the node with the given path. The call will succeed if such a node
 * exists, and the given version matches the node's version (if the given
 * version is -1, it matches any node's versions).
 * <p>
 * A KeeperException with error code KeeperException.NoNode will be thrown
 * if the nodes does not exist.
 * <p>
 * A KeeperException with error code KeeperException.BadVersion will be
 * thrown if the given version does not match the node's version.
 * <p>
 * A KeeperException with error code KeeperException.NotEmpty will be thrown
 * if the node has children.
 * <p>
 * This operation, if successful, will trigger all the watches on the node
 * of the given path left by exists API calls, and the watches on the parent
 * node left by getChildren API calls.
 *
 * @param path
 *                the path of the node to be deleted.
 * @param version
 *                the expected node version.
 * @throws InterruptedException IF the server transaction is interrupted
 * @throws KeeperException If the server signals an error with a non-zero
 *   return code.
 * @throws IllegalArgumentException if an invalid path is specified
 */
public void delete(final String path, int version)
    throws InterruptedException, KeeperException
{
    final String clientPath = path;
    PathUtils.validatePath(clientPath);

    final String serverPath;

    // maintain semantics even in chroot case
    // specifically - root cannot be deleted
    // I think this makes sense even in chroot case.
    if (clientPath.equals("/")) {
        // a bit of a hack, but delete(/) will never succeed and ensures
        // that the same semantics are maintained
        serverPath = clientPath;
    } else {
        serverPath = prependChroot(clientPath);
    }

    RequestHeader h = new RequestHeader();
    h.setType(ZooDefs.OpCode.delete);
    DeleteRequest request = new DeleteRequest();
    request.setPath(serverPath);
    request.setVersion(version);
    ReplyHeader r = cnxn.submitRequest(h, request, null, null);
    if (r.getErr() != 0) {
        throw KeeperException.create(KeeperException.Code.get(r.getErr()),
                clientPath);
    }
}

/**
 * The Asynchronous version of delete. The request doesn't actually until
 * the asynchronous callback is called.
 *
 * @see #delete(String, int)
 */
public void delete(final String path, int version, VoidCallback cb,
        Object ctx)
{
    final String clientPath = path;
    PathUtils.validatePath(clientPath);

    final String serverPath;

    // maintain semantics even in chroot case
    // specifically - root cannot be deleted
    // I think this makes sense even in chroot case.
    if (clientPath.equals("/")) {
        // a bit of a hack, but delete(/) will never succeed and ensures
        // that the same semantics are maintained
        serverPath = clientPath;
    } else {
        serverPath = prependChroot(clientPath);
    }

    RequestHeader h = new RequestHeader();
    h.setType(ZooDefs.OpCode.delete);
    DeleteRequest request = new DeleteRequest();
    request.setPath(serverPath);
    request.setVersion(version);
    cnxn.queuePacket(h, new ReplyHeader(), request, null, cb, clientPath,
            serverPath, ctx, null);
}

/**
 * Delete the node with the given path. The call will succeed if such a node
 * exists, and the given version matches the node's version (if the given
 * version is -1, it matches any node's versions).
 * <p>
 * A KeeperException with error code KeeperException.NoNode will be thrown
 * if the nodes does not exist.
 * <p>
 * A KeeperException with error code KeeperException.BadVersion will be
 * thrown if the given version does not match the node's version.
 * <p>
 * A KeeperException with error code KeeperException.NotEmpty will be thrown
 * if the node has children.
 * <p>
 * This operation, if successful, will trigger all the watches on the node
 * of the given path left by exists API calls, and the watches on the parent
 * node left by getChildren API calls.
 *
 * @param path
 *                the path of the node to be deleted.
 * @param version
 *                the expected node version.
 * @throws InterruptedException IF the server transaction is interrupted
 * @throws KeeperException If the server signals an error with a non-zero
 *   return code.
 * @throws IllegalArgumentException if an invalid path is specified
 */
public void delete(final String path, int version)
    throws InterruptedException, KeeperException
{
    final String clientPath = path;
    PathUtils.validatePath(clientPath);

    final String serverPath;

    // maintain semantics even in chroot case
    // specifically - root cannot be deleted
    // I think this makes sense even in chroot case.
    if (clientPath.equals("/")) {
        // a bit of a hack, but delete(/) will never succeed and ensures
        // that the same semantics are maintained
        serverPath = clientPath;
    } else {
        serverPath = prependChroot(clientPath);
    }

    RequestHeader h = new RequestHeader();
    h.setType(ZooDefs.OpCode.delete);
    DeleteRequest request = new DeleteRequest();
    request.setPath(serverPath);
    request.setVersion(version);
    ReplyHeader r = cnxn.submitRequest(h, request, null, null);
    if (r.getErr() != 0) {
        throw KeeperException.create(KeeperException.Code.get(r.getErr()),
                clientPath);
    }
}

/**
 * The asynchronous version of delete.
 *
 * @see #delete(String, int)
 */
public void delete(final String path, int version, VoidCallback cb,
        Object ctx)
{
    final String clientPath = path;
    PathUtils.validatePath(clientPath);

    final String serverPath;

    // maintain semantics even in chroot case
    // specifically - root cannot be deleted
    // I think this makes sense even in chroot case.
    if (clientPath.equals("/")) {
        // a bit of a hack, but delete(/) will never succeed and ensures
        // that the same semantics are maintained
        serverPath = clientPath;
    } else {
        serverPath = prependChroot(clientPath);
    }

    RequestHeader h = new RequestHeader();
    h.setType(ZooDefs.OpCode.delete);
    DeleteRequest request = new DeleteRequest();
    request.setPath(serverPath);
    request.setVersion(version);
    cnxn.queuePacket(h, new ReplyHeader(), request, null, cb, clientPath,
            serverPath, ctx, null);
}

private EventType checkType(Record response) {

        if (response == null) {
            return EventType.other;
        } else if (response instanceof ConnectRequest) {
            return EventType.write;
        } else if (response instanceof CreateRequest) {
            return EventType.write;
        } else if (response instanceof DeleteRequest) {
            return EventType.write;
        } else if (response instanceof SetDataRequest) {
            return EventType.write;
        } else if (response instanceof SetACLRequest) {
            return EventType.write;
        } else if (response instanceof SetMaxChildrenRequest) {
            return EventType.write;
        } else if (response instanceof SetSASLRequest) {
            return EventType.write;
        } else if (response instanceof SetWatches) {
            return EventType.write;
        } else if (response instanceof SyncRequest) {
            return EventType.write;
        } else if (response instanceof ExistsRequest) {
            return EventType.read;
        } else if (response instanceof GetDataRequest) {
            return EventType.read;
        } else if (response instanceof GetMaxChildrenRequest) {
            return EventType.read;
        } else if (response instanceof GetACLRequest) {
            return EventType.read;
        } else if (response instanceof GetChildrenRequest) {
            return EventType.read;
        } else if (response instanceof GetChildren2Request) {
            return EventType.read;
        } else if (response instanceof GetSASLRequest) {
            return EventType.read;
        } else {
            return EventType.other;
        }
    }

/**
 * Delete the node with the given path. The call will succeed if such a node
 * exists, and the given version matches the node's version (if the given
 * version is -1, it matches any node's versions).
 * <p>
 * A KeeperException with error code KeeperException.NoNode will be thrown
 * if the nodes does not exist.
 * <p>
 * A KeeperException with error code KeeperException.BadVersion will be
 * thrown if the given version does not match the node's version.
 * <p>
 * A KeeperException with error code KeeperException.NotEmpty will be thrown
 * if the node has children.
 * <p>
 * This operation, if successful, will trigger all the watches on the node
 * of the given path left by exists API calls, and the watches on the parent
 * node left by getChildren API calls.
 *
 * @param path
 *                the path of the node to be deleted.
 * @param version
 *                the expected node version.
 * @throws InterruptedException IF the server transaction is interrupted
 * @throws KeeperException If the server signals an error with a non-zero
 *   return code.
 * @throws IllegalArgumentException if an invalid path is specified
 */
public void delete(final String path, int version)
    throws InterruptedException, KeeperException
{
    final String clientPath = path;
    PathUtils.validatePath(clientPath);

    final String serverPath;

    // maintain semantics even in chroot case
    // specifically - root cannot be deleted
    // I think this makes sense even in chroot case.
    if (clientPath.equals("/")) {
        // a bit of a hack, but delete(/) will never succeed and ensures
        // that the same semantics are maintained
        serverPath = clientPath;
    } else {
        serverPath = prependChroot(clientPath);
    }

    RequestHeader h = new RequestHeader();
    h.setType(ZooDefs.OpCode.delete);
    DeleteRequest request = new DeleteRequest();
    request.setPath(serverPath);
    request.setVersion(version);
    ReplyHeader r = cnxn.submitRequest(h, request, null, null);
    if (r.getErr() != 0) {
        throw KeeperException.create(KeeperException.Code.get(r.getErr()),
                clientPath);
    }
}

/**
 * The asynchronous version of delete.
 *
 * @see #delete(String, int)
 */
public void delete(final String path, int version, VoidCallback cb,
        Object ctx)
{
    final String clientPath = path;
    PathUtils.validatePath(clientPath);

    final String serverPath;

    // maintain semantics even in chroot case
    // specifically - root cannot be deleted
    // I think this makes sense even in chroot case.
    if (clientPath.equals("/")) {
        // a bit of a hack, but delete(/) will never succeed and ensures
        // that the same semantics are maintained
        serverPath = clientPath;
    } else {
        serverPath = prependChroot(clientPath);
    }

    RequestHeader h = new RequestHeader();
    h.setType(ZooDefs.OpCode.delete);
    DeleteRequest request = new DeleteRequest();
    request.setPath(serverPath);
    request.setVersion(version);
    cnxn.queuePacket(h, new ReplyHeader(), request, null, cb, clientPath,
            serverPath, ctx, null);
}

/**
 * Delete the node with the given path. The call will succeed if such a node
 * exists, and the given version matches the node's version (if the given
 * version is -1, it matches any node's versions).
 * <p>
 * A KeeperException with error code KeeperException.NoNode will be thrown
 * if the nodes does not exist.
 * <p>
 * A KeeperException with error code KeeperException.BadVersion will be
 * thrown if the given version does not match the node's version.
 * <p>
 * A KeeperException with error code KeeperException.NotEmpty will be thrown
 * if the node has children.
 * <p>
 * This operation, if successful, will trigger all the watches on the node
 * of the given path left by exists API calls, and the watches on the parent
 * node left by getChildren API calls.
 *
 * @param path
 *                the path of the node to be deleted.
 * @param version
 *                the expected node version.
 * @throws InterruptedException IF the server transaction is interrupted
 * @throws KeeperException If the server signals an error with a non-zero
 *   return code.
 * @throws IllegalArgumentException if an invalid path is specified
 */
public void delete(final String path, int version)
    throws InterruptedException, KeeperException
{
    final String clientPath = path;
    PathUtils.validatePath(clientPath);

    final String serverPath;

    // maintain semantics even in chroot case
    // specifically - root cannot be deleted
    // I think this makes sense even in chroot case.
    if (clientPath.equals("/")) {
        // a bit of a hack, but delete(/) will never succeed and ensures
        // that the same semantics are maintained
        serverPath = clientPath;
    } else {
        serverPath = prependChroot(clientPath);
    }

    RequestHeader h = new RequestHeader();
    h.setType(ZooDefs.OpCode.delete);
    DeleteRequest request = new DeleteRequest();
    request.setPath(serverPath);
    request.setVersion(version);
    ReplyHeader r = cnxn.submitRequest(h, request, null, null);
    if (r.getErr() != 0) {
        throw KeeperException.create(KeeperException.Code.get(r.getErr()),
                clientPath);
    }
}

/**
 * The asynchronous version of delete.
 *
 * @see #delete(String, int)
 */
public void delete(final String path, int version, VoidCallback cb,
        Object ctx)
{
    final String clientPath = path;
    PathUtils.validatePath(clientPath);

    final String serverPath;

    // maintain semantics even in chroot case
    // specifically - root cannot be deleted
    // I think this makes sense even in chroot case.
    if (clientPath.equals("/")) {
        // a bit of a hack, but delete(/) will never succeed and ensures
        // that the same semantics are maintained
        serverPath = clientPath;
    } else {
        serverPath = prependChroot(clientPath);
    }

    RequestHeader h = new RequestHeader();
    h.setType(ZooDefs.OpCode.delete);
    DeleteRequest request = new DeleteRequest();
    request.setPath(serverPath);
    request.setVersion(version);
    cnxn.queuePacket(h, new ReplyHeader(), request, null, cb, clientPath,
            serverPath, ctx, null);
}

private static void deleteNodeFailSilent(ZooKeeperWatcher zkw,
    DeleteNodeFailSilent dnfs) throws KeeperException {
  DeleteRequest delete = (DeleteRequest)toZooKeeperOp(zkw, dnfs).toRequestRecord();
  try {
    zkw.getRecoverableZooKeeper().delete(delete.getPath(), delete.getVersion());
  } catch(KeeperException.NoNodeException nne) {
  } catch(InterruptedException ie) {
    zkw.interruptedException(ie);
  }
}

private static void deleteNodeFailSilent(ZooKeeperWatcher zkw,
    DeleteNodeFailSilent dnfs) throws KeeperException {
  DeleteRequest delete = (DeleteRequest)toZooKeeperOp(zkw, dnfs).toRequestRecord();
  try {
    zkw.getRecoverableZooKeeper().delete(delete.getPath(), delete.getVersion());
  } catch(KeeperException.NoNodeException nne) {
  } catch(InterruptedException ie) {
    zkw.interruptedException(ie);
  }
}

private static void deleteNodeFailSilent(ZooKeeperWatcher zkw,
    DeleteNodeFailSilent dnfs) throws KeeperException {
  DeleteRequest delete = (DeleteRequest)toZooKeeperOp(zkw, dnfs).toRequestRecord();
  try {
    zkw.getRecoverableZooKeeper().delete(delete.getPath(), delete.getVersion());
  } catch(KeeperException.NoNodeException nne) {
  } catch(InterruptedException ie) {
    zkw.interruptedException(ie);
  }
}

private static void deleteNodeFailSilent(ZooKeeperWatcher zkw,
    DeleteNodeFailSilent dnfs) throws KeeperException {
  DeleteRequest delete = (DeleteRequest)toZooKeeperOp(zkw, dnfs).toRequestRecord();
  try {
    zkw.getRecoverableZooKeeper().delete(delete.getPath(), delete.getVersion());
  } catch(KeeperException.NoNodeException nne) {
  } catch(InterruptedException ie) {
    zkw.interruptedException(ie);
  }
}

private static void deleteNodeFailSilent(ZKWatcher zkw,
    DeleteNodeFailSilent dnfs) throws KeeperException {
  DeleteRequest delete = (DeleteRequest)toZooKeeperOp(zkw, dnfs).toRequestRecord();
  try {
    zkw.getRecoverableZooKeeper().delete(delete.getPath(), delete.getVersion());
  } catch(KeeperException.NoNodeException nne) {
  } catch(InterruptedException ie) {
    zkw.interruptedException(ie);
  }
}

private static void deleteNodeFailSilent(ZooKeeperWatcher zkw,
    DeleteNodeFailSilent dnfs) throws KeeperException {
  DeleteRequest delete = (DeleteRequest)toZooKeeperOp(zkw, dnfs).toRequestRecord();
  try {
    zkw.getRecoverableZooKeeper().delete(delete.getPath(), delete.getVersion());
  } catch(KeeperException.NoNodeException nne) {
  } catch(InterruptedException ie) {
    zkw.interruptedException(ie);
  }
}

private static void deleteNodeFailSilent(ZooKeeperWatcher zkw,
    DeleteNodeFailSilent dnfs) throws KeeperException {
  DeleteRequest delete = (DeleteRequest)toZooKeeperOp(zkw, dnfs).toRequestRecord();
  try {
    zkw.getRecoverableZooKeeper().delete(delete.getPath(), delete.getVersion());
  } catch(KeeperException.NoNodeException nne) {
  } catch(InterruptedException ie) {
    zkw.interruptedException(ie);
  }
}

/**
 * Delete the node with the given path. The call will succeed if such a node
 * exists, and the given version matches the node's version (if the given
 * version is -1, it matches any node's versions).
 * <p>
 * A KeeperException with error code KeeperException.NoNode will be thrown
 * if the nodes does not exist.
 * <p>
 * A KeeperException with error code KeeperException.BadVersion will be
 * thrown if the given version does not match the node's version.
 * <p>
 * A KeeperException with error code KeeperException.NotEmpty will be thrown
 * if the node has children.
 * <p>
 * This operation, if successful, will trigger all the watches on the node
 * of the given path left by exists API calls, and the watches on the parent
 * node left by getChildren API calls.
 *
 * @param path
 *                the path of the node to be deleted.
 * @param version
 *                the expected node version.
 * @throws InterruptedException IF the server transaction is interrupted
 * @throws KeeperException If the server signals an error with a non-zero
 *   return code.
 * @throws IllegalArgumentException if an invalid path is specified
 */
public void delete(final String path, int version)
    throws InterruptedException, KeeperException
{
    final String clientPath = path;
    PathUtils.validatePath(clientPath);

    final String serverPath;

    // maintain semantics even in chroot case
    // specifically - root cannot be deleted
    // I think this makes sense even in chroot case.
    if (clientPath.equals("/")) {
        // a bit of a hack, but delete(/) will never succeed and ensures
        // that the same semantics are maintained
        serverPath = clientPath;
    } else {
        serverPath = prependChroot(clientPath);
    }

    RequestHeader h = new RequestHeader();
    h.setType(ZooDefs.OpCode.delete);
    DeleteRequest request = new DeleteRequest();
    request.setPath(serverPath);
    request.setVersion(version);
    ReplyHeader r = cnxn.submitRequest(h, request, null, null);
    if (r.getErr() != 0) {
        throw KeeperException.create(KeeperException.Code.get(r.getErr()),
                clientPath);
    }
}

/**
 * The Asynchronous version of delete. The request doesn't actually until
 * the asynchronous callback is called.
 *
 * @see #delete(String, int)
 */
public void delete(final String path, int version, VoidCallback cb,
        Object ctx)
{
    final String clientPath = path;
    PathUtils.validatePath(clientPath);

    final String serverPath;

    // maintain semantics even in chroot case
    // specifically - root cannot be deleted
    // I think this makes sense even in chroot case.
    if (clientPath.equals("/")) {
        // a bit of a hack, but delete(/) will never succeed and ensures
        // that the same semantics are maintained
        serverPath = clientPath;
    } else {
        serverPath = prependChroot(clientPath);
    }

    RequestHeader h = new RequestHeader();
    h.setType(ZooDefs.OpCode.delete);
    DeleteRequest request = new DeleteRequest();
    request.setPath(serverPath);
    request.setVersion(version);
    cnxn.queuePacket(h, new ReplyHeader(), request, null, cb, clientPath,
            serverPath, ctx, null);
}

private static void deleteNodeFailSilent(ZooKeeperWatcher zkw,
    DeleteNodeFailSilent dnfs) throws KeeperException {
  DeleteRequest delete = (DeleteRequest)toZooKeeperOp(zkw, dnfs).toRequestRecord();
  try {
    zkw.getRecoverableZooKeeper().delete(delete.getPath(), delete.getVersion());
  } catch(KeeperException.NoNodeException nne) {
  } catch(InterruptedException ie) {
    zkw.interruptedException(ie);
  }
}

private static void deleteNodeFailSilent(ZooKeeperWatcher zkw,
    DeleteNodeFailSilent dnfs) throws KeeperException {
  DeleteRequest delete = (DeleteRequest)toZooKeeperOp(zkw, dnfs).toRequestRecord();
  try {
    zkw.getRecoverableZooKeeper().delete(delete.getPath(), delete.getVersion());
  } catch(KeeperException.NoNodeException nne) {
  } catch(InterruptedException ie) {
    zkw.interruptedException(ie);
  }
}

private static void deleteNodeFailSilent(ZooKeeperWatcher zkw,
    DeleteNodeFailSilent dnfs) throws KeeperException {
  DeleteRequest delete = (DeleteRequest)toZooKeeperOp(zkw, dnfs).toRequestRecord();
  try {
    zkw.getRecoverableZooKeeper().delete(delete.getPath(), delete.getVersion());
  } catch(KeeperException.NoNodeException nne) {
  } catch(InterruptedException ie) {
    zkw.interruptedException(ie);
  }
}

private static void deleteNodeFailSilent(ZooKeeperWatcher zkw,
    DeleteNodeFailSilent dnfs) throws KeeperException {
  DeleteRequest delete = (DeleteRequest)toZooKeeperOp(zkw, dnfs).toRequestRecord();
  try {
    zkw.getRecoverableZooKeeper().delete(delete.getPath(), delete.getVersion());
  } catch(KeeperException.NoNodeException nne) {
  } catch(InterruptedException ie) {
    zkw.interruptedException(ie);
  }
}

@Override
public Record toRequestRecord() {
    return new DeleteRequest(getPath(), version);
}

@Override
public Record toRequestRecord() {
    return new DeleteRequest(getPath(), version);
}

@Override
public Record toRequestRecord() {
    return new DeleteRequest(getPath(), version);
}

@Override
public Record toRequestRecord() {
    return new DeleteRequest(getPath(), version);
}

@Override
public Record toRequestRecord() {
    return new DeleteRequest(getPath(), version);
}