If there is an error with deleting one of the sub-nodes in the tree, this operation would abort and would be the responsibility of the app to handle the same. See {@link #delete(String, int)} for more details. @throws IllegalArgumentException if an invalid path is specified]]> Important: All versions, of all nodes, under the given node are deleted.

If there is an error with deleting one of the sub-nodes in the tree, this operation would abort and would be the responsibility of the app to handle the same.

@param zk the zookeeper handle @param pathRoot the path to be deleted @param cb call back method @param ctx the context the callback method is called with @throws IllegalArgumentException if an invalid path is specified]]> Important: This is not an atomic snapshot of the tree ever, but the state as it exists across multiple RPCs from zkClient to the ensemble. For practical purposes, it is suggested to bring the clients to the ensemble down (i.e. prevent writes to pathRoot) to 'simulate' a snapshot behavior. @param zk the zookeeper handle @param pathRoot The znode path, for which the entire subtree needs to be listed. @throws InterruptedException @throws KeeperException]]> Session establishment is asynchronous. This constructor will initiate connection to the server and return immediately - potentially (usually) before the session is fully established. The watcher argument specifies the watcher that will be notified of any changes in state. This notification can come at any point before or after the constructor call has returned.

The instantiated ZooKeeper client object will pick an arbitrary server from the connectString and attempt to connect to it. If establishment of the connection fails, another server in the connect string will be tried (the order is non-deterministic, as we random shuffle the list), until a connection is established. The client will continue attempts until the session is explicitly closed.

Added in 3.2.0: An optional "chroot" suffix may also be appended to the connection string. This will run the client commands while interpreting all paths relative to this root (similar to the unix chroot command). @param connectString comma separated host:port pairs, each corresponding to a zk server. e.g. "127.0.0.1:3000,127.0.0.1:3001,127.0.0.1:3002" If the optional chroot suffix is used the example would look like: "127.0.0.1:3000,127.0.0.1:3001,127.0.0.1:3002/app/a" where the client would be rooted at "/app/a" and all paths would be relative to this root - ie getting/setting/etc... "/foo/bar" would result in operations being run on "/app/a/foo/bar" (from the server perspective). @param sessionTimeout session timeout in milliseconds @param watcher a watcher object which will be notified of state changes, may also be notified for node events @throws IOException in cases of network failure @throws IllegalArgumentException if an invalid chroot path is specified]]> Session establishment is asynchronous. This constructor will initiate connection to the server and return immediately - potentially (usually) before the session is fully established. The watcher argument specifies the watcher that will be notified of any changes in state. This notification can come at any point before or after the constructor call has returned.

The instantiated ZooKeeper client object will pick an arbitrary server from the connectString and attempt to connect to it. If establishment of the connection fails, another server in the connect string will be tried (the order is non-deterministic, as we random shuffle the list), until a connection is established. The client will continue attempts until the session is explicitly closed.

Added in 3.2.0: An optional "chroot" suffix may also be appended to the connection string. This will run the client commands while interpreting all paths relative to this root (similar to the unix chroot command). @param connectString comma separated host:port pairs, each corresponding to a zk server. e.g. "127.0.0.1:3000,127.0.0.1:3001,127.0.0.1:3002" If the optional chroot suffix is used the example would look like: "127.0.0.1:3000,127.0.0.1:3001,127.0.0.1:3002/app/a" where the client would be rooted at "/app/a" and all paths would be relative to this root - ie getting/setting/etc... "/foo/bar" would result in operations being run on "/app/a/foo/bar" (from the server perspective). @param sessionTimeout session timeout in milliseconds @param watcher a watcher object which will be notified of state changes, may also be notified for node events @param canBeReadOnly (added in 3.4) whether the created client is allowed to go to read-only mode in case of partitioning. Read-only mode basically means that if the client can't find any majority servers but there's partitioned server it could reach, it connects to one in read-only mode, i.e. read requests are allowed while write requests are not. It continues seeking for majority in the background. @throws IOException in cases of network failure @throws IllegalArgumentException if an invalid chroot path is specified]]> Session establishment is asynchronous. This constructor will initiate connection to the server and return immediately - potentially (usually) before the session is fully established. The watcher argument specifies the watcher that will be notified of any changes in state. This notification can come at any point before or after the constructor call has returned.

The instantiated ZooKeeper client object will pick an arbitrary server from the connectString and attempt to connect to it. If establishment of the connection fails, another server in the connect string will be tried (the order is non-deterministic, as we random shuffle the list), until a connection is established. The client will continue attempts until the session is explicitly closed (or the session is expired by the server).

Added in 3.2.0: An optional "chroot" suffix may also be appended to the connection string. This will run the client commands while interpreting all paths relative to this root (similar to the unix chroot command).

Use {@link #getSessionId} and {@link #getSessionPasswd} on an established client connection, these values must be passed as sessionId and sessionPasswd respectively if reconnecting. Otherwise, if not reconnecting, use the other constructor which does not require these parameters. @param connectString comma separated host:port pairs, each corresponding to a zk server. e.g. "127.0.0.1:3000,127.0.0.1:3001,127.0.0.1:3002" If the optional chroot suffix is used the example would look like: "127.0.0.1:3000,127.0.0.1:3001,127.0.0.1:3002/app/a" where the client would be rooted at "/app/a" and all paths would be relative to this root - ie getting/setting/etc... "/foo/bar" would result in operations being run on "/app/a/foo/bar" (from the server perspective). @param sessionTimeout session timeout in milliseconds @param watcher a watcher object which will be notified of state changes, may also be notified for node events @param sessionId specific session id to use if reconnecting @param sessionPasswd password for this session @throws IOException in cases of network failure @throws IllegalArgumentException if an invalid chroot path is specified @throws IllegalArgumentException for an invalid list of ZooKeeper hosts]]> Session establishment is asynchronous. This constructor will initiate connection to the server and return immediately - potentially (usually) before the session is fully established. The watcher argument specifies the watcher that will be notified of any changes in state. This notification can come at any point before or after the constructor call has returned.

The instantiated ZooKeeper client object will pick an arbitrary server from the connectString and attempt to connect to it. If establishment of the connection fails, another server in the connect string will be tried (the order is non-deterministic, as we random shuffle the list), until a connection is established. The client will continue attempts until the session is explicitly closed (or the session is expired by the server).

Added in 3.2.0: An optional "chroot" suffix may also be appended to the connection string. This will run the client commands while interpreting all paths relative to this root (similar to the unix chroot command).

Use {@link #getSessionId} and {@link #getSessionPasswd} on an established client connection, these values must be passed as sessionId and sessionPasswd respectively if reconnecting. Otherwise, if not reconnecting, use the other constructor which does not require these parameters. @param connectString comma separated host:port pairs, each corresponding to a zk server. e.g. "127.0.0.1:3000,127.0.0.1:3001,127.0.0.1:3002" If the optional chroot suffix is used the example would look like: "127.0.0.1:3000,127.0.0.1:3001,127.0.0.1:3002/app/a" where the client would be rooted at "/app/a" and all paths would be relative to this root - ie getting/setting/etc... "/foo/bar" would result in operations being run on "/app/a/foo/bar" (from the server perspective). @param sessionTimeout session timeout in milliseconds @param watcher a watcher object which will be notified of state changes, may also be notified for node events @param sessionId specific session id to use if reconnecting @param sessionPasswd password for this session @param canBeReadOnly (added in 3.4) whether the created client is allowed to go to read-only mode in case of partitioning. Read-only mode basically means that if the client can't find any majority servers but there's partitioned server it could reach, it connects to one in read-only mode, i.e. read requests are allowed while write requests are not. It continues seeking for majority in the background. @throws IOException in cases of network failure @throws IllegalArgumentException if an invalid chroot path is specified]]> The flags argument specifies whether the created node will be ephemeral or not.

An ephemeral node will be removed by the ZooKeeper automatically when the session associated with the creation of the node expires.

The flags argument can also specify to create a sequential node. The actual path name of a sequential node will be the given path plus a suffix "i" where i is the current sequential number of the node. The sequence number is always fixed length of 10 digits, 0 padded. Once such a node is created, the sequential number will be incremented by one.

If a node with the same actual path already exists in the ZooKeeper, a KeeperException with error code KeeperException.NodeExists will be thrown. Note that since a different actual path is used for each invocation of creating sequential node with the same path argument, the call will never throw "file exists" KeeperException.

If the parent node does not exist in the ZooKeeper, a KeeperException with error code KeeperException.NoNode will be thrown.

An ephemeral node cannot have children. If the parent node of the given path is ephemeral, a KeeperException with error code KeeperException.NoChildrenForEphemerals will be thrown.

This operation, if successful, will trigger all the watches left on the node of the given path by exists and getData API calls, and the watches left on the parent node by getChildren API calls.

If a node is created successfully, the ZooKeeper server will trigger the watches on the path left by exists calls, and the watches on the parent of the node by getChildren calls.

The maximum allowable size of the data array is 1 MB (1,048,576 bytes). Arrays larger than this will cause a KeeperExecption to be thrown. @param path the path for the node @param data the initial data for the node @param acl the acl for the node @param createMode specifying whether the node to be created is ephemeral and/or sequential @return the actual path of the created node @throws KeeperException if the server returns a non-zero error code @throws KeeperException.InvalidACLException if the ACL is invalid, null, or empty @throws InterruptedException if the transaction is interrupted @throws IllegalArgumentException if an invalid path is specified]]> A KeeperException with error code KeeperException.NoNode will be thrown if the nodes does not exist.

A KeeperException with error code KeeperException.BadVersion will be thrown if the given version does not match the node's version.

A KeeperException with error code KeeperException.NotEmpty will be thrown if the node has children.

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]]> On success, a list of results is returned. On failure, an exception is raised which contains partial results and error details, see {@link KeeperException#getResults}

Note: The maximum allowable size of all of the data arrays in all of the setData operations in this single request is typically 1 MB (1,048,576 bytes). This limit is specified on the server via jute.maxbuffer. Requests larger than this will cause a KeeperException to be thrown. @param ops An iterable that contains the operations to be done. These should be created using the factory methods on {@link Op}. @return A list of results, one for each input Op, the order of which exactly matches the order of the ops input operations. @throws InterruptedException If the operation was interrupted. The operation may or may not have succeeded, but will not have partially succeeded if this exception is thrown. @throws KeeperException If the operation could not be completed due to some error in doing one of the specified ops. @throws IllegalArgumentException if an invalid path is specified @since 3.4.0]]> If the watch is non-null and the call is successful (no exception is thrown), a watch will be left on the node with the given path. The watch will be triggered by a successful operation that creates/delete the node or sets the data on the node. @param path the node path @param watcher explicit watcher @return the stat of the node of the given path; return null if no such a node exists. @throws KeeperException If the server signals an error @throws InterruptedException If the server transaction is interrupted. @throws IllegalArgumentException if an invalid path is specified]]> If the watch is true and the call is successful (no exception is thrown), a watch will be left on the node with the given path. The watch will be triggered by a successful operation that creates/delete the node or sets the data on the node. @param path the node path @param watch whether need to watch this node @return the stat of the node of the given path; return null if no such a node exists. @throws KeeperException If the server signals an error @throws InterruptedException If the server transaction is interrupted.]]> If the watch is non-null and the call is successful (no exception is thrown), a watch will be left on the node with the given path. The watch will be triggered by a successful operation that sets data on the node, or deletes the node.

A KeeperException with error code KeeperException.NoNode will be thrown if no node with the given path exists. @param path the given path @param watcher explicit watcher @param stat the stat of the node @return the data of the node @throws KeeperException If the server signals an error with a non-zero error code @throws InterruptedException If the server transaction is interrupted. @throws IllegalArgumentException if an invalid path is specified]]> If the watch is true and the call is successful (no exception is thrown), a watch will be left on the node with the given path. The watch will be triggered by a successful operation that sets data on the node, or deletes the node.

A KeeperException with error code KeeperException.NoNode will be thrown if no node with the given path exists. @param path the given path @param watch whether need to watch this node @param stat the stat of the node @return the data of the node @throws KeeperException If the server signals an error with a non-zero error code @throws InterruptedException If the server transaction is interrupted.]]> This operation, if successful, will trigger all the watches on the node of the given path left by getData calls.

A KeeperException with error code KeeperException.NoNode will be thrown if no node with the given path exists.

A KeeperException with error code KeeperException.BadVersion will be thrown if the given version does not match the node's version.

The maximum allowable size of the data array is 1 MB (1,048,576 bytes). Arrays larger than this will cause a KeeperException to be thrown. @param path the path of the node @param data the data to set @param version the expected matching version @return the state of the node @throws InterruptedException If the server transaction is interrupted. @throws KeeperException If the server signals an error with a non-zero error code. @throws IllegalArgumentException if an invalid path is specified]]> A KeeperException with error code KeeperException.NoNode will be thrown if no node with the given path exists. @param path the given path for the node @param stat the stat of the node will be copied to this parameter if not null. @return the ACL array of the given node. @throws InterruptedException If the server transaction is interrupted. @throws KeeperException If the server signals an error with a non-zero error code. @throws IllegalArgumentException if an invalid path is specified]]> A KeeperException with error code KeeperException.NoNode will be thrown if no node with the given path exists.

A KeeperException with error code KeeperException.BadVersion will be thrown if the given aclVersion does not match the node's aclVersion. @param path the given path for the node @param acl the given acl for the node @param aclVersion the given acl version of the node @return the stat of the node. @throws InterruptedException If the server transaction is interrupted. @throws KeeperException If the server signals an error with a non-zero error code. @throws org.apache.zookeeper.KeeperException.InvalidACLException If the acl is invalide. @throws IllegalArgumentException if an invalid path is specified]]> If the watch is non-null and the call is successful (no exception is thrown), a watch will be left on the node with the given path. The watch willbe triggered by a successful operation that deletes the node of the given path or creates/delete a child under the node.

The list of children returned is not sorted and no guarantee is provided as to its natural or lexical order.

A KeeperException with error code KeeperException.NoNode will be thrown if no node with the given path exists. @param path @param watcher explicit watcher @return an unordered array of children of the node with the given path @throws InterruptedException If the server transaction is interrupted. @throws KeeperException If the server signals an error with a non-zero error code. @throws IllegalArgumentException if an invalid path is specified]]> If the watch is true and the call is successful (no exception is thrown), a watch will be left on the node with the given path. The watch willbe triggered by a successful operation that deletes the node of the given path or creates/delete a child under the node.

The list of children returned is not sorted and no guarantee is provided as to its natural or lexical order.

A KeeperException with error code KeeperException.NoNode will be thrown if no node with the given path exists. @param path @param watch @return an unordered array of children of the node with the given path @throws InterruptedException If the server transaction is interrupted. @throws KeeperException If the server signals an error with a non-zero error code.]]> If the watch is non-null and the call is successful (no exception is thrown), a watch will be left on the node with the given path. The watch willbe triggered by a successful operation that deletes the node of the given path or creates/delete a child under the node.

The list of children returned is not sorted and no guarantee is provided as to its natural or lexical order.

A KeeperException with error code KeeperException.NoNode will be thrown if no node with the given path exists. @since 3.3.0 @param path @param watcher explicit watcher @param stat stat of the znode designated by path @return an unordered array of children of the node with the given path @throws InterruptedException If the server transaction is interrupted. @throws KeeperException If the server signals an error with a non-zero error code. @throws IllegalArgumentException if an invalid path is specified]]> If the watch is true and the call is successful (no exception is thrown), a watch will be left on the node with the given path. The watch willbe triggered by a successful operation that deletes the node of the given path or creates/delete a child under the node.

The list of children returned is not sorted and no guarantee is provided as to its natural or lexical order.

A KeeperException with error code KeeperException.NoNode will be thrown if no node with the given path exists. @since 3.3.0 @param path @param watch @param stat stat of the znode designated by path @return an unordered array of children of the node with the given path @throws InterruptedException If the server transaction is interrupted. @throws KeeperException If the server signals an error with a non-zero error code.]]> Once a connection to a server is established, a session ID is assigned to the client. The client will send heart beats to the server periodically to keep the session valid.

The application can call ZooKeeper APIs through a client as long as the session ID of the client remains valid.

If for some reason, the client fails to send heart beats to the server for a prolonged period of time (exceeding the sessionTimeout value, for instance), the server will expire the session, and the session ID will become invalid. The client object will no longer be usable. To make ZooKeeper API calls, the application must create a new client object.

If the ZooKeeper server the client currently connects to fails or otherwise does not respond, the client will automatically try to connect to another server before its session ID expires. If successful, the application can continue to use the client.

The ZooKeeper API methods are either synchronous or asynchronous. Synchronous methods blocks until the server has responded. Asynchronous methods just queue the request for sending and return immediately. They take a callback object that will be executed either on successful execution of the request or on error with an appropriate return code (rc) indicating the error.

Some successful ZooKeeper API calls can leave watches on the "data nodes" in the ZooKeeper server. Other successful ZooKeeper API calls can trigger those watches. Once a watch is triggered, an event will be delivered to the client which left the watch at the first place. Each watch can be triggered only once. Thus, up to one event will be delivered to a client for every watch it leaves.

A client needs an object of a class implementing Watcher interface for processing the events delivered to the client. When a client drops the current connection and re-connects to a server, all the existing watches are considered as being triggered but the undelivered events are lost. To emulate this, the client will generate a special event to tell the event handler a connection has been dropped. This special event has EventType None and KeeperState Disconnected.]]>