ZooKeeper学习之zookeeper的ACL(AUTH)
1.如果学想学习Zookeeper的watcher Api请点击这里:Watcher事件类型和ZK状态
2.Zookeeper的ACL(AUTH)介绍：
zookeeper的ACL(AUTH)
ACL(Access Control List),Zookeeper作为一个分布式协调框架，其内部存储的都是一些关于分布式
系统运行时状态的元数据，尤其是设计到一些分布式锁，Master选举和协调等应用场景。我们需要有
效地保障Zookeeper中的数据安全，Zookeeper提供了三种模式。权限模式，授权对象，权限。
权限模式：Scheme,开发人员最多使用的如下四种权限模式：
IP:ip模式通过ip地址粒度进行权限控制模式，例如配置了：192.168.110.135即表示权限控
制都是针对这个ip地址的，同时也支持按网段分配，比如：192.168.110.*
Digest:digest是最常用的权限控制模式，也更符合我们对权限控制的认识，其类似于
"username:password"形式的权限标识进行权限配置。ZK会对形成的权限标识先后进
行两次编码处理，粉笔是SHA-1加密算法和Base64编码。
World：World是一直最开放的权限控制模式。这种模式可以看做为特殊的Digest，他仅仅是
一个标识而已。
Super：超级用户模式，在超级用户模式下可以对ZK任意进行操作。
权限对象：值得是权限赋予的用户或者是一个指定的实体，例如ip地址或机器等。在不同的模式下，
授权对象是不同的。这种模式和权限对象一一对应。
权限：权限就是指那些通过权限检测后可以被允许执行的操作，在ZK中，对数据的操作权限分为以下
五大类：create,delete,read,write,admin3.实例代码:
package com.adai.zookeeper.three.auth;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.ZooDefs.Ids;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.ACL;
/**
* 工具类,为了测试zookeeper权限(ACL),封装了zookeeper一些api
* @author adai
* @since 20170913 01:28
*
*/
public class ZookeeperUtil {
//连接地址
public static final String CONNECT_ADDR = "192.168.110.135,192.168.110.136,192.168.110.137";
//会话连接超时时间
public static final int SESSION_TIMEOUT = 2000;
//测试数据跟路径
public static final String ROOT_PATH = "/testAuth";
public static final String CHILDREN = "/testAuth/children";
public static final String CHILDRENAUTH = "/testAuth/children2";
//认证方式
public static final String AUTH_TYPE = "digest";
//正确的认证方法
public static final String CORRECTAUTH = "adai";
//错误的认证方法
public static final String BADAUTH = "adai1";
//计数器
public static final AtomicInteger SEQ = new AtomicInteger();
public static final String LOG_PRE_OF_MAIN = "【main】:";
/**
* 得到指定节点的数据内容
* @param zoo zookeeper对象
* @param path 节点的全路径
* @param String zookeeperCliName 用来区别是哪一个zookeeper类调用的Util方法
*/
public static void getData(ZooKeeper zoo , String path , String zookeeperCliName){
try {
String data = new String(zoo.getData(path, false, null));
System.out.println(zookeeperCliName+"得到节点对应的数据为:"+path+":"+data);
} catch (Exception e) {
System.out.println(zookeeperCliName+"获取数据失败："+path+"---失败原因："+e.getMessage());
}
}
/**
* 更新指定节点的内容
* @param zoo zookeeper对象
* @param path 节点的全路径
* @param data 更新的数据
* @param zookeeperCliName 用来区别是哪一个zookeeper类调用的Util方法
*/
public static void setData(ZooKeeper zoo , String path , String data , String zookeeperCliName){
try {
zoo.setData(path, data.getBytes(), -1); // -1忽略所有版本检查
System.out.println(zookeeperCliName+":节点更新成功 "+path+":"+data);
} catch (Exception e) {
System.out.println(zookeeperCliName+":节点更新失败 "+path+":"+data+"---失败原因："+e.getMessage());
}
}
/**
* 删除节点
* @param zoo ZooKeeper对象
* @param path 节点路径
* @param , String zookeeperCliName 用来区别是哪一个zookeeper类调用的Util方法
*/
public static void deleteNode(ZooKeeper zoo , String path , String zookeeperCliName){
try {
zoo.delete(path, -1);// -1忽略所有版本号
System.out.println(zookeeperCliName+":删除成功:"+path);
} catch (Exception e) {
System.out.println(zookeeperCliName+":删除节点失败："+path+"--失败原因："+e.getMessage());
}
}
/**
*
* @param zoo ZooKeeper对象
* @param path 节点路径
* @param zookeeperCliName 用来区别是哪一个zookeeper类调用的Util方法
*/
public static void exist(ZooKeeper zoo , String path , String zookeeperCliName){
try {
zoo.exists(path, false);
System.out.println(zookeeperCliName+":判断节点是否存在成功:"+path);
} catch (Exception e) {
System.out.println(zookeeperCliName+":判断节点是否存在失败:"+path+"---失败原因:"+e.getMessage());
}
}
/**
* 创建一个具有认证权限的节点
* @param zoo ZooKeeper对象
* @param path 节点路径
* @param data 节点数据
* @param acls 权限
* @param createMode 节点存储数据的模式
* @param zookeeperCliName 用来区别是哪一个zookeeper类调用的Util方法
*/
public static void createAuthNode(ZooKeeper zoo , String path, String data,
List acls, CreateMode createMode , String zookeeperCliName) {
try {
zoo.create(path, data.getBytes(), acls, createMode);
System.out.println(zookeeperCliName+":创建了一个具有相应权限的节点成功:"+path+":"+data);
} catch (Exception e) {
System.out.println(zookeeperCliName+":创建了一个具有相应权限的节点失败:"+path+":"+data+"---失败原因:"+e.getMessage());
}
}
/**
* 创建一个普通的节点（不具有权限约束的节点）
* @param zoo ZooKeeper对象
* @param path 节点路径
* @param data 节点数据
* @param zookeeperCliName 用来区别是哪一个zookeeper类调用的Util方法
*/
public static void createNodePath(ZooKeeper zoo , String path , String data , String zookeeperCliName ){
try {
zoo.create(path, data.getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
System.out.println(zookeeperCliName+":创建了一个新的节点成功:"+path+":"+data);
} catch (Exception e) {
System.out.println(zookeeperCliName+":创建了一个新的节点失败:"+path+":"+data+"---失败原因:"+e.getMessage());
}
}
/**
* 释放资源
* @param zoo ZooKeeper对象
*/
public static void close(ZooKeeper zoo){
if(zoo != null ){
try {
zoo.close();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
} package com.adai.zookeeper.three.auth;
import java.util.concurrent.CountDownLatch;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.Watcher.Event.EventType;
import org.apache.zookeeper.Watcher.Event.KeeperState;
/**
*
* @author adai
* @since 20170913 0132
*/
/**
* ZookeeperWatcher类,如果使用了watcher事件会触发该类的process方法。
* 第一次连接zookeeper服务器的时候也会触发
* @author Administrator
*
*/
public class ZookeeperWatcher implements Watcher{
//用来阻塞线程，等待客户端成功连接zookeeper服务器。
private CountDownLatch correctAuthZooKeeper = null;
//用来打印日记时，目的是为了知道是哪一个创建的zookeeper
private String log_process = "";
public ZookeeperWatcher(CountDownLatch correctAuthZooKeeper , String zookeeperCliName){
this.correctAuthZooKeeper = correctAuthZooKeeper;
log_process = zookeeperCliName;
}
@Override
public void process(WatchedEvent event) {
if(event == null ) return;
log_process = "【"+log_process+" watche-"+ZookeeperUtil.SEQ.addAndGet(1)+"】";
String path = event.getPath(); // 受影响的节点路径
EventType enventType = event.getType(); // 事件类型(一共有四种)
KeeperState stat = event.getState() ; // ZK状态(一共有四种)
if(KeeperState.SyncConnected == stat){
if(EventType.None == enventType){
System.out.println(log_process+":连接zookeeper服务器成功");
correctAuthZooKeeper.countDown();
}
}else if(KeeperState.Disconnected == stat){
System.out.println(log_process+":连接zookeeper服务器失败");
}else if(KeeperState.Expired == stat){
System.out.println(log_process+":连接zookeeper服务器会话已经过期");
}else if(KeeperState.AuthFailed == stat){
System.out.println(log_process+":连接zookeeper服务器认证失败");
}
System.out.println("------------------------------------");
}
}package com.adai.zookeeper.three.auth;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.ZooDefs.Ids;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.ACL;
import org.apache.zookeeper.data.Stat;
/**
*
* @author adai
* @since 20170912 10:47
* 拥有某种权限的zookeeper的客户端(权限类型为:digest 所对应的具体权限:adai【类型用户名密码验证等】)
*/
public class AuthZookeeper {
private CountDownLatch countDownLatch = new CountDownLatch(1);
private ZooKeeper zoo = null ;
public AuthZookeeper(){
try {
zoo = new ZooKeeper(ZookeeperUtil.CONNECT_ADDR,
ZookeeperUtil.SESSION_TIMEOUT,
new ZookeeperWatcher(countDownLatch,"AuthZookeeper"));
//授权 参数1：权限类型 参数2:对应的正确权限（CorrectAuthZookeeper创建的节点权限与其一致）
zoo.addAuthInfo(ZookeeperUtil.AUTH_TYPE, ZookeeperUtil.CORRECTAUTH.getBytes());
countDownLatch.await();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 释放连接
*/
public void close(){
if(zoo != null ){
try {
zoo.close();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public ZooKeeper getCorrectAuthZookeeper(){
return zoo;
}
/**
* 创建一个具有认证权限的节点
* @param path
* @param data
*/
public void createAuthNode(String path , String data){
try {
Stat stat = zoo.exists(path, false);
if (stat != null){
System.out.println(path+"节点已经存在:");
return ;
}
} catch (Exception e) {
}
List acls = new ArrayList(1);
for (ACL ids_acl : Ids.CREATOR_ALL_ACL) { //遍历出所有权限类型
acls.add(ids_acl);
}
ZookeeperUtil.createAuthNode(zoo , path, data, acls, CreateMode.PERSISTENT ,"AuthZookeeper");
}
} package com.adai.zookeeper.three.auth;
import java.util.concurrent.CountDownLatch;
import org.apache.zookeeper.ZooKeeper;
/**
* 拥有某种权限的zookeeper客户端，该权限与AuthZookeeper类的权限一致
* 多以AuthZookeeper类创建的节点，该客户端可以对该节点进行相应的操作(如：节点数据的获取：修改数据，删除数据等)
* @author adai
* @since 20170912 11:03
*
*/
public class CorrectAuthZookeeper {
private CountDownLatch countDownLatch = new CountDownLatch(1);
private ZooKeeper zoo = null ;
public CorrectAuthZookeeper(){
try {
zoo = new ZooKeeper(ZookeeperUtil.CONNECT_ADDR,
ZookeeperUtil.SESSION_TIMEOUT,
new ZookeeperWatcher(countDownLatch,"CorrectAuthZookeeper"));
//授权 参数1：权限类型 参数2:对应的正确权限（AuthZookeeper创建的节点权限一致）
zoo.addAuthInfo(ZookeeperUtil.AUTH_TYPE, ZookeeperUtil.CORRECTAUTH.getBytes());
countDownLatch.await();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 释放连接
*/
public void close(){
if(zoo != null ){
try {
zoo.close();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public ZooKeeper getCorrectAuthZookeeper(){
return zoo;
}
}
package com.adai.zookeeper.three.auth;
import java.util.concurrent.CountDownLatch;
import org.apache.zookeeper.ZooKeeper;
/**
* 拥有某种权限的zookeeper客户端，该权限与AuthZookeeper类的权限不一致
* 所以AuthZookeeper类创建的节点，该客户端不可以对该节点进行相应的操作(如：节点数据的获取：修改数据，删除数据等)
* 但可以进行创建新的节点
* @author adai
* @since 20170912 11:02
*
*/
public class BadAuthZookeeper {
private CountDownLatch countDownLatch = new CountDownLatch(1);
private ZooKeeper zoo = null ;
public BadAuthZookeeper(){
try {
zoo = new ZooKeeper(ZookeeperUtil.CONNECT_ADDR,
ZookeeperUtil.SESSION_TIMEOUT,
new ZookeeperWatcher(countDownLatch,"BadAuthZookeeper"));
//授权 参数1：权限类型 参数2:对应的正确权限（AuthZookeeper创建的节点权限不一致）
zoo.addAuthInfo(ZookeeperUtil.AUTH_TYPE, ZookeeperUtil.BADAUTH.getBytes());
countDownLatch.await();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 释放连接
*/
public void close(){
if(zoo != null ){
try {
zoo.close();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public ZooKeeper getCorrectAuthZookeeper(){
return zoo;
}
}
package com.adai.zookeeper.three.auth;
import java.util.concurrent.CountDownLatch;
import org.apache.zookeeper.ZooKeeper;
/**
*
* @author adai
* @since 20170912 11:00
* 没有任何权限的zookeeper客户端，不能操作AuthZookeeper客户端创建的节点(如：节点数据的获取：修改数据，删除数据等)
*/
public class NotAuthZookeeper {
private CountDownLatch countDownLatch = new CountDownLatch(1);
private ZooKeeper zoo = null ;
public NotAuthZookeeper(){
try {
zoo = new ZooKeeper(ZookeeperUtil.CONNECT_ADDR,
ZookeeperUtil.SESSION_TIMEOUT,
new ZookeeperWatcher(countDownLatch,"NotAuthZookeeper"));
countDownLatch.await();
} catch (Exception e) {
e.printStackTrace();
}
}
public void close(){
if(zoo != null ){
try {
zoo.close();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public ZooKeeper getCorrectAuthZookeeper(){
return zoo;
}
}
package com.adai.zookeeper.three.auth;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.ZooDefs.Ids;
import org.apache.zookeeper.data.ACL;
import org.apache.zookeeper.data.Stat;
/**
*
* @author adai
* @since 20170912 10:46
* 测试zookeeper权限类
*/
public class TestMain {
private static ExecutorService executorService = null;
private static ZooKeeper correctAuthZookeeper = null ;
private static ZooKeeper badAuthZookeeper = null ;
private static ZooKeeper notAuthZookeeper = null ;
private static AuthZookeeper authZookeeper = null ;
private static CountDownLatch countDownLatch = new CountDownLatch(4);
public static void main(String[] args) throws InterruptedException {
// executorService = Executors.newFixedThreadPool(4);
executorService = new ThreadPoolExecutor(
4, // corePoolSize 核心线程数 （核心线程数不能大于最大线程数）
4, // maximumPoolSize 最大线程数 当使用无界队列时，该参数没有任何意义，无界队列执行的一次为核心线程的任务数
2000, // keepAliveTime 空闲时间
TimeUnit.MILLISECONDS, // 时间单位(分)
new LinkedBlockingQueue() // workQueue 使用何种队列机制
);
connect();
countDownLatch.await(); // 等待所有zookeeper客户端连接服务器成功
//该客户端创建的节点具有权限，其他客户端要访问该节点，必须要与该节点的权限一致才能访问
authZookeeper.createAuthNode(ZookeeperUtil.ROOT_PATH, " adai");
// exist();
// setDate();
// getDate();
// createNodePath();
// setNodeData();
// getNodeDate();
// delete();
// createNodePathOrAllAuth();
deleteNodeAllAuth();
deleteRoot();
close();
}
/**
* 所有客户端异步连接zookeeper服务器
*/
public static void connect(){
executorService.execute(new Runnable() {
@Override
public void run() {
authZookeeper = new AuthZookeeper();
countDownLatch.countDown();
}
});
executorService.execute(new Runnable() {
@Override
public void run() {
correctAuthZookeeper = new CorrectAuthZookeeper().getCorrectAuthZookeeper();
countDownLatch.countDown();
}
});
executorService.execute(new Runnable() {
@Override
public void run() {
badAuthZookeeper = new BadAuthZookeeper().getCorrectAuthZookeeper();
countDownLatch.countDown();
}
});
executorService.execute(new Runnable() {
@Override
public void run() {
notAuthZookeeper = new NotAuthZookeeper().getCorrectAuthZookeeper();
countDownLatch.countDown();
}
});
}
/**
*correctAuthZookeeper得到节点对应的数据为:/testAuth: adai
*badAuthZookeeper获取数据失败：/testAuth---失败原因：KeeperErrorCode = NoAuth for /testAuth
*notAuthZookeeper获取数据失败：/testAuth---失败原因：KeeperErrorCode = NoAuth for /testAuth
*/
public static void getDate(){
ZookeeperUtil.getData(correctAuthZookeeper, ZookeeperUtil.ROOT_PATH, "correctAuthZookeeper");
ZookeeperUtil.getData(badAuthZookeeper, ZookeeperUtil.ROOT_PATH, "badAuthZookeeper");
ZookeeperUtil.getData(notAuthZookeeper, ZookeeperUtil.ROOT_PATH, "notAuthZookeeper");
}
/**
* correctAuthZookeeper:节点更新成功 /testAuth:auth correctAuthZookeeper
*badAuthZookeeper:节点更新失败 /testAuth:auth badAuthZookeeper---失败原因：KeeperErrorCode = NoAuth for /testAuth
*notAuthZookeeper:节点更新失败 /testAuth:auth notAuthZookeeper---失败原因：KeeperErrorCode = NoAuth for /testAuth
*/
public static void setDate(){
ZookeeperUtil.setData(correctAuthZookeeper,ZookeeperUtil.ROOT_PATH,
"auth correctAuthZookeeper","correctAuthZookeeper");
ZookeeperUtil.setData(badAuthZookeeper,ZookeeperUtil.ROOT_PATH,
"auth badAuthZookeeper","badAuthZookeeper");
ZookeeperUtil.setData(notAuthZookeeper,ZookeeperUtil.ROOT_PATH,
"auth notAuthZookeeper","notAuthZookeeper");
}
/**
*AuthZookeeper:创建了一个具有相应权限的节点成功:/testAuth: adai
*correctAuthZookeeper:判断节点是否存在成功:/testAuth
*badAuthZookeeper:判断节点是否存在成功:/testAuth
*notAuthZookeeper:判断节点是否存在成功:/testAuth
*/
public static void exist(){
ZookeeperUtil.exist(correctAuthZookeeper, ZookeeperUtil.ROOT_PATH, "correctAuthZookeeper");
ZookeeperUtil.exist(badAuthZookeeper, ZookeeperUtil.ROOT_PATH, "badAuthZookeeper");
ZookeeperUtil.exist(notAuthZookeeper, ZookeeperUtil.ROOT_PATH, "notAuthZookeeper");
}
/**
*correctAuthZookeeper:创建了一个新的节点成功:/testAuth/children: adai children correctAuthZookeeper
*badAuthZookeeper:创建了一个新的节点失败:/testAuth/children:
* adai children badAuthZookeeper---失败原因:KeeperErrorCode = NoAuth for /testAuth/children
*notAuthZookeeper:创建了一个新的节点失败:/testAuth/children:
* adai children notAuthZookeeper---失败原因:KeeperErrorCode = NoAuth for /testAuth/children
*/
public static void createNodePath(){
ZookeeperUtil.createNodePath(correctAuthZookeeper, ZookeeperUtil.CHILDREN,
" adai children correctAuthZookeeper", "correctAuthZookeeper");
ZookeeperUtil.createNodePath(badAuthZookeeper, ZookeeperUtil.CHILDREN+"2",
" adai children badAuthZookeeper", "badAuthZookeeper");
ZookeeperUtil.createNodePath(notAuthZookeeper, ZookeeperUtil.CHILDREN+"3",
" adai children notAuthZookeeper", "notAuthZookeeper");
}
/**
*correctAuthZookeeper:节点更新成功 /testAuth/children:set nodeData correctAuthZookeeper
*badAuthZookeeper:节点更新成功 /testAuth/children:set nodeData badAuthZookeeper
*notAuthZookeeper:节点更新成功 /testAuth/children:set nodeData notAuthZookeeper
*疑问?为什么子节点会更新成功(请比较两个创建自己的方法有什么不同)
*/
public static void setNodeData(){
ZookeeperUtil.setData(correctAuthZookeeper, ZookeeperUtil.CHILDREN,
"set nodeData correctAuthZookeeper", "correctAuthZookeeper");
ZookeeperUtil.setData(badAuthZookeeper, ZookeeperUtil.CHILDREN,
"set nodeData badAuthZookeeper", "badAuthZookeeper");
ZookeeperUtil.setData(notAuthZookeeper, ZookeeperUtil.CHILDREN,
"set nodeData notAuthZookeeper", "notAuthZookeeper");
}
/**
点击打开链接 *correctAuthZookeeper得到节点对应的数据为:/testAuth/children:set nodeData notAuthZookeeper
*badAuthZookeeper得到节点对应的数据为:/testAuth/children:set nodeData notAuthZookeeper
*notAuthZookeeper得到节点对应的数据为:/testAuth/children:set nodeData notAuthZookeeper
*答上疑问，因为correctAuthZookeeper创建子节点没有将所有权限作为参数传入，而用的是Ids.OPEN_ACL_UNSAFE传入。
*/
public static void getNodeDate(){
ZookeeperUtil.getData(correctAuthZookeeper, ZookeeperUtil.CHILDREN, "correctAuthZookeeper");
ZookeeperUtil.getData(badAuthZookeeper, ZookeeperUtil.CHILDREN, "badAuthZookeeper");
ZookeeperUtil.getData(notAuthZookeeper, ZookeeperUtil.CHILDREN, "notAuthZookeeper");
}
/**
* badAuthZookeeper:删除节点失败：/testAuth/children--失败原因：KeeperErrorCode = NoAuth for /testAuth/children
* notAuthZookeeper:删除节点失败：/testAuth/children--失败原因：KeeperErrorCode = NoAuth for /testAuth/children
* correctAuthZookeeper:删除成功:/testAuth/children
*/
public static void delete(){
ZookeeperUtil.deleteNode(badAuthZookeeper, ZookeeperUtil.CHILDREN,"badAuthZookeeper");
ZookeeperUtil.deleteNode(notAuthZookeeper, ZookeeperUtil.CHILDREN,"notAuthZookeeper");
ZookeeperUtil.deleteNode(correctAuthZookeeper, ZookeeperUtil.CHILDREN,"correctAuthZookeeper");
}
public static void close(){
ZookeeperUtil.close(correctAuthZookeeper);
ZookeeperUtil.close(badAuthZookeeper);
ZookeeperUtil.close(notAuthZookeeper);
ZookeeperUtil.close(authZookeeper.getCorrectAuthZookeeper());
executorService.shutdown(); // 等待任务执行完后释放资源
System.out.println("释放资源完毕");
}
/**
* 解决上文疑问
* CorrectAuthZookeeper:创建了一个具有相应权限的节点成功:/testAuth/children2: adai all atuh create correctAuthZookeeper
* correctAuthZookeeper:节点更新成功 /testAuth/children2:set nodeData to AllAuth correctAuthZookeeper
* badAuthZookeeper:节点更新失败 /testAuth/children2:set nodeData2 to AllAuth badAuthZookeeper
* ---失败原因：KeeperErrorCode = NoAuth for /testAuth/children2
* notAuthZookeeper:节点更新失败 /testAuth/children2:set nodeData2 to AllAuth notAuthZookeeper
* ---失败原因：KeeperErrorCode = NoAuth for /testAuth/children2
*/
public static void createNodePathOrAllAuth(){
try {
Stat stat = correctAuthZookeeper.exists(ZookeeperUtil.CHILDRENAUTH, false);
if (stat != null){
System.out.println(ZookeeperUtil.CHILDRENAUTH+"节点已经存在:");
return ;
}
} catch (Exception e) {
}
List acls = new ArrayList(1);
for (ACL ids_acl : Ids.CREATOR_ALL_ACL) { //遍历出所有权限类型
acls.add(ids_acl);
}
ZookeeperUtil.createAuthNode(correctAuthZookeeper, ZookeeperUtil.CHILDRENAUTH,
" adai all atuh create correctAuthZookeeper", acls, CreateMode.PERSISTENT, "CorrectAuthZookeeper");
ZookeeperUtil.setData(correctAuthZookeeper, ZookeeperUtil.CHILDRENAUTH,
"set nodeData to AllAuth correctAuthZookeeper", "correctAuthZookeeper");
ZookeeperUtil.setData(badAuthZookeeper, ZookeeperUtil.CHILDRENAUTH,
"set nodeData2 to AllAuth badAuthZookeeper", "badAuthZookeeper");
ZookeeperUtil.setData(notAuthZookeeper, ZookeeperUtil.CHILDRENAUTH,
"set nodeData2 to AllAuth notAuthZookeeper", "notAuthZookeeper");
}
public static void deleteNodeAllAuth(){
ZookeeperUtil.deleteNode(badAuthZookeeper, ZookeeperUtil.CHILDRENAUTH,"badAuthZookeeper");
ZookeeperUtil.deleteNode(notAuthZookeeper, ZookeeperUtil.CHILDRENAUTH,"notAuthZookeeper");
ZookeeperUtil.deleteNode(correctAuthZookeeper, ZookeeperUtil.CHILDRENAUTH,"correctAuthZookeeper");
}
public static void deleteRoot(){
ZookeeperUtil.deleteNode(badAuthZookeeper, ZookeeperUtil.ROOT_PATH,"badAuthZookeeper");
ZookeeperUtil.deleteNode(notAuthZookeeper, ZookeeperUtil.ROOT_PATH,"notAuthZookeeper");
ZookeeperUtil.deleteNode(correctAuthZookeeper, ZookeeperUtil.ROOT_PATH,"correctAuthZookeeper");
}
}
如果以上代码有问题，请您告知我一下：qq:1721995310,也可以评论区里告知一声，在此说声感谢。更多关于zookeeper的学习，请点击这里: 点击打开链接