Java 类org.apache.zookeeper.proto.DeleteRequest 实例源码

项目：https-github.com-apache-zookeeper 文件：ZooKeeper.java

/**
 * 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);
    }
}

项目：https-github.com-apache-zookeeper 文件：ZooKeeper.java

/**
 * 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);
}

项目：ditb 文件：ZKUtil.java

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);
  }
}

项目：bigstreams 文件：ZooKeeper.java

/**
 * 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);
    }
}

项目：bigstreams 文件：ZooKeeper.java

/**
 * 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);
}

项目：zookeeper-src-learning 文件：ZooKeeper.java

/**
 * 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);
    }
}

项目：zookeeper-src-learning 文件：ZooKeeper.java

/**
 * 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);
}

项目：incubator-pulsar 文件：ClientCnxnAspect.java

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;
        }
    }

项目：SecureKeeper 文件：ZooKeeper.java

/**
 * 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);
    }
}

项目：SecureKeeper 文件：ZooKeeper.java

/**
 * 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);
}

项目：SecureKeeper 文件：ZooKeeper.java

/**
 * 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);
    }
}

项目：SecureKeeper 文件：ZooKeeper.java

/**
 * 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);
}

项目：LCIndex-HBase-0.94.16 文件：ZKUtil.java

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);
  }
}

项目：pbase 文件：ZKUtil.java

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);
  }
}

项目：HIndex 文件：ZKUtil.java

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);
  }
}

项目：IRIndex 文件：ZKUtil.java

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);
  }
}

项目：hbase 文件：ZKUtil.java

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);
  }
}

项目：PyroDB 文件：ZKUtil.java

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);
  }
}

项目：c5 文件：ZKUtil.java

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);
  }
}

项目：zookeeper.dsc 文件：ZooKeeper.java

/**
 * 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);
    }
}

项目：zookeeper.dsc 文件：ZooKeeper.java

/**
 * 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);
}

项目：HBase-Research 文件：ZKUtil.java

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);
  }
}

项目：hbase-0.94.8-qod 文件：ZKUtil.java

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);
  }
}

项目：hbase-0.94.8-qod 文件：ZKUtil.java

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);
  }
}

项目：hindex 文件：ZKUtil.java

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);
  }
}

项目：fuck_zookeeper 文件：Op.java

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

项目：https-github.com-apache-zookeeper 文件：Op.java

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

项目：ZooKeeper 文件：Op.java

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

项目：StreamProcessingInfrastructure 文件：Op.java

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

项目：bigstreams 文件：Op.java

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

项目：zookeeper-src-learning 文件：Op.java

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

项目：zookeeper 文件：Op.java

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

项目：SecureKeeper 文件：Op.java

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

项目：SecureKeeper 文件：Op.java

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

项目：StreamBench 文件：Op.java

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

项目：ACaZoo 文件：Op.java

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

项目：curator 文件：CuratorMultiTransactionImpl.java

@Override
public List<CuratorTransactionResult> forOperations(List<CuratorOp> operations) throws Exception
{
    operations = Preconditions.checkNotNull(operations, "operations cannot be null");
    Preconditions.checkArgument(!operations.isEmpty(), "operations list cannot be empty");

    CuratorMultiTransactionRecord record = new CuratorMultiTransactionRecord();
    for ( CuratorOp curatorOp : operations )
    {
        Schema schema = client.getSchemaSet().getSchema(curatorOp.getTypeAndPath().getForPath());
        record.add(curatorOp.get(), curatorOp.getTypeAndPath().getType(), curatorOp.getTypeAndPath().getForPath());
        if ( (curatorOp.get().getType() == ZooDefs.OpCode.create) || (curatorOp.get().getType() == ZooDefs.OpCode.createContainer) )
        {
            CreateRequest createRequest = (CreateRequest)curatorOp.get().toRequestRecord();
            CreateMode createMode;
            if ( client.isZk34CompatibilityMode() )
            {
                try
                {
                    createMode = CreateMode.fromFlag(createRequest.getFlags());
                }
                catch ( KeeperException.BadArgumentsException dummy )
                {
                    createMode = CreateMode.PERSISTENT;
                }
            }
            else
            {
                createMode = CreateMode.fromFlag(createRequest.getFlags(), CreateMode.PERSISTENT);
            }
            schema.validateCreate(createMode, createRequest.getPath(), createRequest.getData(), createRequest.getAcl());
        }
        else if ( (curatorOp.get().getType() == ZooDefs.OpCode.delete) || (curatorOp.get().getType() == ZooDefs.OpCode.deleteContainer) )
        {
            DeleteRequest deleteRequest = (DeleteRequest)curatorOp.get().toRequestRecord();
            schema.validateDelete(deleteRequest.getPath());
        }
        else if ( curatorOp.get().getType() == ZooDefs.OpCode.setData )
        {
            SetDataRequest setDataRequest = (SetDataRequest)curatorOp.get().toRequestRecord();
            schema.validateGeneral(setDataRequest.getPath(), setDataRequest.getData(), null);
        }
    }

    if ( backgrounding.inBackground() )
    {
        client.processBackgroundOperation(new OperationAndData<>(this, record, backgrounding.getCallback(), null, backgrounding.getContext(), null), null);
        return null;
    }
    else
    {
        return forOperationsInForeground(record);
    }
}

项目：LoadBalanced_zk 文件：Op.java

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

项目：LoadBalanced_zk 文件：Op.java

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

项目：zookeeper-lite 文件：IDeleteRequest.java

public IDeleteRequest() {
    this(new DeleteRequest());
}