ZooKeeper

mkdir zookeeper-tutorial && cd zookeeper-tutorial

version: '3.9'

services:
  zk1:
    image: zookeeper:3.9.4
    container_name: zk1
    restart: unless-stopped
    hostname: zk1
    ports:
      - "2181:2181"
    environment:
      ZOO_MY_ID: 1
      ZOO_SERVERS: server.1=zk1:2888:3888;2181 server.2=zk2:2888:3888;2181 server.3=zk3:2888:3888;2181
      ZOO_4LW_COMMANDS_WHITELIST: "*"
    volumes:
      - zk1_data:/data
      - zk1_datalog:/datalog

  zk2:
    image: zookeeper:3.9.4
    container_name: zk2
    restart: unless-stopped
    hostname: zk2
    ports:
      - "2182:2181"
    environment:
      ZOO_MY_ID: 2
      ZOO_SERVERS: server.1=zk1:2888:3888;2181 server.2=zk2:2888:3888;2181 server.3=zk3:2888:3888;2181
      ZOO_4LW_COMMANDS_WHITELIST: "*"
    volumes:
      - zk2_data:/data
      - zk2_datalog:/datalog

  zk3:
    image: zookeeper:3.9.4
    container_name: zk3
    restart: unless-stopped
    hostname: zk3
    ports:
      - "2183:2181"
    environment:
      ZOO_MY_ID: 3
      ZOO_SERVERS: server.1=zk1:2888:3888;2181 server.2=zk2:2888:3888;2181 server.3=zk3:2888:3888;2181
      ZOO_4LW_COMMANDS_WHITELIST: "*"
    volumes:
      - zk3_data:/data
      - zk3_datalog:/datalog

volumes:
  zk1_data:
  zk1_datalog:
  zk2_data:
  zk2_datalog:
  zk3_data:
  zk3_datalog:

docker-compose down -v

docker-compose up -d

docker logs zk1
docker logs zk2
docker logs zk3

docker exec -it zk1 bash

root@zk3:/apache-zookeeper-3.9.4-bin# ls
bin  conf  docs  lib  LICENSE.txt  NOTICE.txt  README.md  README_packaging.md

root@zk3:/apache-zookeeper-3.9.4-bin/bin# ll -lrt
total 88
-rwxr-xr-x 1 zookeeper zookeeper  1385 Aug 19 19:49 zkTxnLogToolkit.sh*
-rwxr-xr-x 1 zookeeper zookeeper   996 Aug 19 19:49 zkTxnLogToolkit.cmd*
-rwxr-xr-x 1 zookeeper zookeeper  1377 Aug 19 19:49 zkSnapShotToolkit.sh*
-rwxr-xr-x 1 zookeeper zookeeper   988 Aug 19 19:49 zkSnapShotToolkit.cmd*
-rwxr-xr-x 1 zookeeper zookeeper  1422 Aug 19 19:49 zkSnapshotRecursiveSummaryToolkit.sh*
-rwxr-xr-x 1 zookeeper zookeeper   995 Aug 19 19:49 zkSnapshotRecursiveSummaryToolkit.cmd*
-rwxr-xr-x 1 zookeeper zookeeper  1374 Aug 19 19:49 zkSnapshotComparer.sh*
-rwxr-xr-x 1 zookeeper zookeeper   987 Aug 19 19:49 zkSnapshotComparer.cmd*
-rwxr-xr-x 1 zookeeper zookeeper 11680 Aug 19 19:49 zkServer.sh*
-rwxr-xr-x 1 zookeeper zookeeper  4559 Aug 19 19:49 zkServer-initialize.sh*
-rwxr-xr-x 1 zookeeper zookeeper  1243 Aug 19 19:49 zkServer.cmd*
-rwxr-xr-x 1 zookeeper zookeeper  3947 Aug 19 19:49 zkEnv.sh*
-rwxr-xr-x 1 zookeeper zookeeper  1810 Aug 19 19:49 zkEnv.cmd*
-rwxr-xr-x 1 zookeeper zookeeper  1576 Aug 19 19:49 zkCli.sh*
-rwxr-xr-x 1 zookeeper zookeeper  1115 Aug 19 19:49 zkCli.cmd*
-rwxr-xr-x 1 zookeeper zookeeper  1978 Aug 19 19:49 zkCleanup.sh*
-rwxr-xr-x 1 zookeeper zookeeper   232 Aug 19 19:49 README.txt*
drwxr-xr-x 2 zookeeper zookeeper  4096 Aug 19 19:49 ./
drwxr-xr-x 6 zookeeper zookeeper  4096 Oct  2 08:52 ../

root@zk3:/apache-zookeeper-3.9.4-bin/bin# ./zkCli.sh 
...
...
2025-10-15 07:41:38,559 [myid:localhost:2181] - INFO  [main-SendThread(localhost:2181):o.a.z.ClientCnxn$SendThread@1427] - Session establishment complete on server localhost/127.0.0.1:2181, session id = 0x30203aaa8590000, negotiated timeout = 30000

WATCHER::

WatchedEvent state:SyncConnected type:None path:null zxid: -1
[zk: localhost:2181(CONNECTED) 0] 

在 zk1中执行
[zk: localhost:2181(CONNECTED) 0] create /test-cluster "Cluster OK"
Created /test-cluster
[zk: localhost:2181(CONNECTED) 1] 

在 zk1中 zkCli连接 zk2
root@zk3:/apache-zookeeper-3.9.4-bin/bin# ./zkCli.sh -server zk2:2181
Connecting to zk2:2181
..
..
2025-10-15 07:44:26,765 [myid:zk2:2181] - INFO  [main-SendThread(zk2:2181):o.a.z.ClientCnxn$SendThread@1427] - Session establishment complete on server zk2/172.18.0.4:2181, session id = 0x20203aaa89b0000, negotiated timeout = 30000

WATCHER::

WatchedEvent state:SyncConnected type:None path:null zxid: -1
[zk: zk2:2181(CONNECTED) 3] ls /
[test-cluster, zookeeper]
[zk: zk2:2181(CONNECTED) 4] get /test-cluster
Cluster OK
[zk: zk2:2181(CONNECTED) 5] 

/
├── zookeeper (系统节点，内置)
├── config
│   ├── db
│   │   └── url = "jdbc:mysql://host:3306/db"
│   └── timeout = "30s"
├── services
│   ├── web1 (临时节点) = "192.168.1.10:8080"
│   └── web2 (顺序节点) = "192.168.1.11:8080"
└── locks
    └── task-0000000001 (临时顺序节点) = "" (空数据，仅路径用于锁)

const zookeeper = require('node-zookeeper-client');

const client = zookeeper.createClient('127.0.0.1:2181');

client.connect();


function testCode() {
    // 创建ZNode时设置Data
    client.create('/config', Buffer.from("jdbc:mysql://localhost:3306"), zookeeper.CreateMode.PERSISTENT, (err, path) => {
        if (err) console.error('Create error:', err);
        else console.log('Created:', path);
    });
    // 读取Data 带Watcher
    client.getData('/config', (event, data, stat) => {
        console.log('Data:', data.toString('utf8'));  // 转为字符串
        console.log('Stat:', stat);  // { version: 0, dataLength: 25, ... }
    }, (err, data, stat) => {
        if (err) console.error('Get error:', err);
        else console.log('Initial Data:', data.toString('utf8'));
    });
    // 修改Data 带版本控制
    client.setData('/config/db', Buffer.from('jdbc:mysql://newhost:3306'), -1, (err, stat) => {  // -1 忽略版本
        if (err) console.error('Set error:', err);
        else console.log('Updated Stat:', stat.version);  // 新版本号
    });
    // 关闭连接
    client.close();
}

client.once('connected', () => {
    console.log('Connected to ZooKeeper.');
    testCode();
});

const zookeeper = require('node-zookeeper-client');

const client = zookeeper.createClient('127.0.0.1:2181');

client.connect();

function listServices() {
    client.getChildren('/services',
        function (event) {
            if (event) {
                console.log('Children changed event:', event);
                // Re-attach watcher recursively
                listServices();
            }
        },
        function (err, children, stat) {
            if (err) {
                console.error('GetChildren error:', err);
                return;
            }
            console.log('Children List:', children);  // e.g., ['node1']
            console.log('Num Children:', stat ? stat.numChildren : 'N/A');
            console.log('cVersion:', stat ? stat.cversion : 'N/A');
        }
    );
}

function testCode() {
    // 0. Create persistent parent node (allows ephemeral children)
    client.create('/services', Buffer.from('fnode'), zookeeper.CreateMode.PERSISTENT, (err, path) => {
        if (err) console.error('services Create error:', err);
        else console.log('services created', path);
    });

    // 1. Create ephemeral child node (adds to list)
    client.create('/services/node1', Buffer.from('ip:8080'), zookeeper.CreateMode.EPHEMERAL, (err, path) => {
        if (err) console.error('Create error:', err);
        else console.log('Added to list:', path);
    });

    // 2. List children with recursive watcher
    listServices();

    // 3. Delete child after delay (to allow initial list and watcher setup)
    setTimeout(() => {
        client.remove('/services/node1', -1, (err) => {
            if (err) console.error('Delete error:', err);
            else console.log('Removed from list');
        });
    }, 1000);

    // 4. Close after more delay (to see delete effect)
    setTimeout(() => {
        client.close();
    }, 2000);
}

client.once('connected', () => {
    console.log('Connected to ZooKeeper.');
    testCode();
});

// root@ser745692301841:/dev_dir/zookeeper-tutorial/js# node index.js
// Connected to ZooKeeper.
// services created /services
// Added to list: /services/node1
// Children List: [ 'node1' ]
// Num Children: 1
// cVersion: 1
// Children changed event: Event { type: 4, name: 'NODE_CHILDREN_CHANGED', path: '/services' }
// Removed from list
// Children List: []
// Num Children: 0
// cVersion: 2

version: '3.9'

services:
  zk1:
    image: zookeeper:3.9.4
    container_name: zk1
    restart: unless-stopped
    hostname: zk1
    ports:
      - "2181:2181"
    networks:
      - zk-net
    environment:
      ZOO_MY_ID: 1
      ZOO_SERVERS: server.1=zk1:2888:3888;2181 server.2=zk2:2888:3888;2181 server.3=zk3:2888:3888;2181
      ZOO_4LW_COMMANDS_WHITELIST: "*"
    volumes:
      - zk1_data:/data
      - zk1_datalog:/datalog
      - ./zoo.cfg:/apache-zookeeper-3.9.4-bin/conf/zoo.cfg

  zk2:
    image: zookeeper:3.9.4
    container_name: zk2
    restart: unless-stopped
    hostname: zk2
    ports:
      - "2182:2181"
    networks:
      - zk-net
    environment:
      ZOO_MY_ID: 2
      ZOO_SERVERS: server.1=zk1:2888:3888;2181 server.2=zk2:2888:3888;2181 server.3=zk3:2888:3888;2181
      ZOO_4LW_COMMANDS_WHITELIST: "*"
    volumes:
      - zk2_data:/data
      - zk2_datalog:/datalog
      - ./zoo.cfg:/apache-zookeeper-3.9.4-bin/conf/zoo.cfg

  zk3:
    image: zookeeper:3.9.4
    container_name: zk3
    restart: unless-stopped
    hostname: zk3
    ports:
      - "2183:2181"
    networks:
      - zk-net
    environment:
      ZOO_MY_ID: 3
      ZOO_SERVERS: server.1=zk1:2888:3888;2181 server.2=zk2:2888:3888;2181 server.3=zk3:2888:3888;2181
      ZOO_4LW_COMMANDS_WHITELIST: "*"
    volumes:
      - zk3_data:/data
      - zk3_datalog:/datalog
      - ./zoo.cfg:/apache-zookeeper-3.9.4-bin/conf/zoo.cfg

volumes:
  zk1_data:
  zk1_datalog:
  zk2_data:
  zk2_datalog:
  zk3_data:
  zk3_datalog:

networks:
  zk-net:
    driver: bridge

# 基本配置
tickTime=2000
initLimit=10
syncLimit=5

# 数据和日志目录（镜像内部路径）
dataDir=/data
dataLogDir=/datalog

# 客户端端口（内部）
clientPort=2181

# 集群服务器配置（使用容器名称作为主机名）
server.1=zk1:2888:3888
server.2=zk2:2888:3888
server.3=zk3:2888:3888

# 启用 Digest 认证提供者
authProvider.1=org.apache.zookeeper.server.auth.DigestAuthenticationProvider

# 超级用户 Digest（admin:admin123 的哈希值）
superDigest=admin:dyks0yAxrXfvFZ7G5BN0+ZUcGCE=

[zk: 127.0.0.1:2181(CONNECTED) 0] addauth digest admin:admin123
[zk: 127.0.0.1:2181(CONNECTED) 1] create /test "data"
Created /test
[zk: 127.0.0.1:2181(CONNECTED) 2] ls /
[test, zookeeper]
[zk: 127.0.0.1:2181(CONNECTED) 3] create /secure-test "protected data" digest:admin:dyks0yAxrXfvFZ7G5BN0+ZUcGCE=:cdrwa
Created /secure-test
[zk: 127.0.0.1:2181(CONNECTED) 4] getAcl /secure-test
'digest,'admin:dyks0yAxrXfvFZ7G5BN0+ZUcGCE=
: cdrwa
[zk: 127.0.0.1:2181(CONNECTED) 5] get /secure-test
protected data
[zk: 127.0.0.1:2181(CONNECTED) 6] 

root@zk1:/apache-zookeeper-3.9.4-bin/bin# ./zkCli.sh -server 127.0.0.1:2181
[zk: 127.0.0.1:2181(CONNECTED) 1] get /secure-test
Insufficient permission : /secure-test
[zk: 127.0.0.1:2181(CONNECTED) 2] 
# 可见没有权限
# 进行AUTH
[zk: 127.0.0.1:2181(CONNECTED) 2] addauth digest admin:admin123
[zk: 127.0.0.1:2181(CONNECTED) 3] get /secure-test
protected data
[zk: 127.0.0.1:2181(CONNECTED) 4] 

const zookeeper = require('node-zookeeper-client');

const client = zookeeper.createClient('127.0.0.1:2181');

client.connect();

function testCode() {
    // Define ACLs after auth
    const worldAcl = new zookeeper.ACL(zookeeper.Permission.ADMIN, new zookeeper.Id('world', 'anyone'));
    const digestAcl = new zookeeper.ACL(zookeeper.Permission.ADMIN, new zookeeper.Id('digest', 'admin:dyks0yAxrXfvFZ7G5BN0+ZUcGCE='));
    const acls = [worldAcl, digestAcl];

    // 2. 创建节点（如果不存在），然后设置 ACL
    client.create('/secure', Buffer.from('initial data'), zookeeper.CreateMode.EPHEMERAL, (err, path) => {
        if (err && err.getCode() !== zookeeper.Exception.NODE_EXISTS) {
            console.error('Create error:', err);
            client.close();
            return;
        }
        console.log('Node /secure created or exists:', path);

        // Now set ACL
        client.setACL('/secure', acls, -1, (err, stat) => {  // -1 ignores version
            if (err) {
                console.error('SetACL error:', err);
                client.close();
                return;
            }
            console.log('ACL set, version:', stat.aversion);

            // 3. 获取 ACL
            client.getACL('/secure', (err, retrievedAcls, stat) => {
                if (err) console.error('GetACL error:', err);
                else {
                    console.log('Retrieved ACLs:', retrievedAcls);
                    console.log('ACL Version:', stat.aversion);

                    // 4. 创建新节点时设置 ACL（正确顺序：data, acls, mode）
                    client.create('/secure-new', Buffer.from('data'), acls, zookeeper.CreateMode.EPHEMERAL, (err, path) => {
                        if (err) console.error('Create error:', err);
                        else console.log('Created with ACL:', path);

                        // 5. 关闭连接
                        setTimeout(() => client.close(), 1000);  // Brief delay to see ephemeral nodes
                    });
                }
            });
        });
    });
}

client.once('connected', () => {
    console.log('Connected to ZooKeeper.');

    // 1. 认证（addAuthInfo）
    client.addAuthInfo('digest', Buffer.from('admin:admin123'));

    console.log('Authentication info added.');

    testCode();
});

// root@ser745692301841:/dev_dir/zookeeper-tutorial/js# node index.js
// Connected to ZooKeeper.
// Authentication info added.
// Node /secure created or exists: /secure
// ACL set, version: 1
// Retrieved ACLs: [
//   ACL { permission: 16, id: Id { scheme: 'world', id: 'anyone' } },
//   ACL {
//     permission: 16,
//     id: Id { scheme: 'digest', id: 'admin:dyks0yAxrXfvFZ7G5BN0+ZUcGCE=' }
//   }
// ]
// ACL Version: 1
// Created with ACL: /secure-new

[zk: localhost:2181(CONNECTED) 0] ls /
[secure-test, test, zookeeper]
[zk: localhost:2181(CONNECTED) 1] stat /test
cZxid = 0x100000004
ctime = Thu Oct 16 08:33:50 UTC 2025
mZxid = 0x100000004
mtime = Thu Oct 16 08:33:50 UTC 2025
pZxid = 0x100000004
cversion = 0
dataVersion = 0
aclVersion = 0
ephemeralOwner = 0x0
dataLength = 4
numChildren = 0
[zk: localhost:2181(CONNECTED) 2] 

const zookeeper = require('node-zookeeper-client');

const client = zookeeper.createClient('127.0.0.1:2181');
client.connect();

// helper：把可能是 Buffer 的字段解析成 Number
function bufToNumber(buf) {
    if (!Buffer.isBuffer(buf)) return buf;

    // 常见两种长度：8 bytes (int64) 或 4 bytes (uint32)
    try {
        if (buf.length === 8 && typeof buf.readBigInt64BE === 'function') {
            const bi = buf.readBigInt64BE(0);
            // 转成 Number 可能会丢精度，但一般 zxid/ctime/mtime 在可表示范围内
            return Number(bi);
        }
        if (buf.length === 8 && typeof buf.readBigInt64LE === 'function') {
            // 如果是小端（不太常见），用 LE
            const bi = buf.readBigInt64LE(0);
            return Number(bi);
        }
        if (buf.length === 4) {
            return buf.readUInt32BE(0);
        }
        // 退而求其次：当做字符串
        return parseInt(buf.toString('hex'), 16);
    } catch (e) {
        // 如果都失败，返回原始 Buffer
        return buf;
    }
}

// 把 stat 里常用字段安全读取并格式化的函数
function formatStat(stat) {
    const get = (name, getterName) => {
        try {
            // 先尝试 getter（如果实现了）
            if (typeof stat[getterName] === 'function') {
                return stat[getterName]();
            }
            // 再尝试直接属性
            if (stat[name] !== undefined) {
                return stat[name];
            }
            // 再尝试小写或不同拼写的属性
            if (stat[name.toLowerCase()] !== undefined) {
                return stat[name.toLowerCase()];
            }
            return undefined;
        } catch (e) {
            return undefined;
        }
    };

    const czxidRaw = get('czxid', 'getCzxid') ?? stat.czxid;
    const mzxidRaw = get('mzxid', 'getMzxid') ?? stat.mzxid;
    const pzxidRaw = get('pzxid', 'getPzxid') ?? stat.pzxid;
    const ctimeRaw = get('ctime', 'getCtime') ?? stat.ctime;
    const mtimeRaw = get('mtime', 'getMtime') ?? stat.mtime;
    // data/version fields在不同实现中名字不同
    const versionRaw = get('version', 'getVersion') ?? stat.version ?? stat.dataVersion;
    const cversionRaw = get('cversion', 'getCversion') ?? stat.cversion;
    const numChildrenRaw = get('numChildren', 'getNumChildren') ?? stat.numChildren;

    // 解析 Buffer -> Number（如果需要）
    const czxid = bufToNumber(czxidRaw);
    const mzxid = bufToNumber(mzxidRaw);
    const pzxid = bufToNumber(pzxidRaw);
    const ctimeNum = bufToNumber(ctimeRaw);
    const mtimeNum = bufToNumber(mtimeRaw);
    const version = bufToNumber(versionRaw);
    const cversion = bufToNumber(cversionRaw);
    const numChildren = bufToNumber(numChildrenRaw);

    return {
        czxid,
        mzxid,
        pzxid,
        ctime: (typeof ctimeNum === 'number' && !Number.isNaN(ctimeNum)) ? new Date(ctimeNum) : ctimeRaw,
        mtime: (typeof mtimeNum === 'number' && !Number.isNaN(mtimeNum)) ? new Date(mtimeNum) : mtimeRaw,
        version,
        cversion,
        numChildren
    };
}

function testCode() {
    // 1. exists -> stat
    client.exists('/secure-test', (err, stat) => {
        if (err) return console.error('Exists error:', err);
        if (!stat) return console.log('Node does not exist');

        console.log('Stat:', formatStat(stat));
    });

    // 2. getData -> data + stat
    client.getData('/secure-test', (err, data, stat) => {
        if (err) return console.error('GetData error:', err);

        console.log('Data:', data ? data.toString('utf8') : null);
        console.log('Stat (from getData):', formatStat(stat));
    });

    // 3. getChildren('/', ...)
    client.getChildren('/', (err, children, stat) => {
        if (err) return console.error('GetChildren error:', err);

        console.log('Children:', children);
        console.log('Root stat:', formatStat(stat));
    });

    // 4. 修改 data（带版本控制）
    client.getData('/secure-test', (err, data, stat) => {
        if (err) return console.error('GetData error before set:', err);

        const fmt = formatStat(stat);
        const expectedVersion = typeof fmt.version === 'number' ? fmt.version : -1;

        client.setData('/secure-test', Buffer.from('updated'), expectedVersion, (err, newStat) => {
            if (err) {
                if (err.getCode && err.getCode() === zookeeper.Exception.BAD_VERSION) {
                    console.error('Version mismatch');
                } else {
                    console.error('SetData error:', err);
                }
            } else {
                console.log('Updated, new stat:', formatStat(newStat));
            }
        });
    });
}

client.once('connected', () => {
    console.log('Connected to ZooKeeper.');
    client.addAuthInfo('digest', Buffer.from('admin:admin123'));
    console.log('Authentication info added.');
    testCode();
});

// root@ser745692301841:/dev_dir/zookeeper-tutorial/js# node index.js
// Connected to ZooKeeper.
// Authentication info added.
// Stat: {
//   czxid: 4294967301,
//   mzxid: 4294967319,
//   pzxid: 4294967301,
//   ctime: 2025-10-16T08:41:32.407Z,
//   mtime: 2025-10-16T17:32:56.581Z,
//   version: 1,
//   cversion: 0,
//   numChildren: 0
// }
// Data: updated
// Stat (from getData): {
//   czxid: 4294967301,
//   mzxid: 4294967319,
//   pzxid: 4294967301,
//   ctime: 2025-10-16T08:41:32.407Z,
//   mtime: 2025-10-16T17:32:56.581Z,
//   version: 1,
//   cversion: 0,
//   numChildren: 0
// }
// Children: [ 'zookeeper', 'test', 'secure-test' ]
// Root stat: {
//   czxid: 0,
//   mzxid: 0,
//   pzxid: 4294967315,
//   ctime: 1970-01-01T00:00:00.000Z,
//   mtime: 1970-01-01T00:00:00.000Z,
//   version: 0,
//   cversion: 7,
//   numChildren: 3
// }
// Updated, new stat: {
//   czxid: 4294967301,
//   mzxid: 4294967328,
//   pzxid: 4294967301,
//   ctime: 2025-10-16T08:41:32.407Z,
//   mtime: 2025-10-16T17:43:33.718Z,
//   version: 2,
//   cversion: 0,
//   numChildren: 0
// }

set /game/state "RUNNING"

tickTime=2000
initLimit=10
syncLimit=5
dataDir=/var/lib/zookeeper
clientPort=2181

# 集群成员定义
server.1=192.168.1.1:2888:3888
server.2=192.168.1.1:2888:3888
server.3=192.168.1.3:2888:3888

const client = zookeeper.createClient('192.168.1.1:2181,192.168.1.2:2181,192.168.1.3:2181');

// server.js
const zookeeper = require('node-zookeeper-client');
const os = require("os");

const client = zookeeper.createClient("127.0.0.1:2181");
const SERVICE_PATH = "/services/myapp";

client.once('connected', () => {
    console.log("Connected to ZooKeeper");
    registerService();
});

client.connect();

function registerService() {
    client.exists(SERVICE_PATH, (err, stat) => {
        if (err) {
            return console.error("exists error:", err);
        }
        if (!stat) {
            client.mkdirp(SERVICE_PATH, (err) => {
                if (err) {
                    return console.error("mkdir error:", err);
                }
                createEphemeralNode();
            });
        } else {
            createEphemeralNode();
        }
    });
}

function createEphemeralNode() {
    const ip = getLocalIP();
    const port = 3000 + Math.floor(Math.random() * 1000);
    const data = JSON.stringify({ ip, port });
    const nodePath = `${SERVICE_PATH}/node-`;

    client.create(nodePath, Buffer.from(data), zookeeper.CreateMode.EPHEMERAL_SEQUENTIAL, (err, path) => {
        if (err) return console.error("create error:", err);
        console.log(`Service registered at ${path} (${data})`);
    });
}

function getLocalIP() {
    const interfaces = os.networkInterfaces();
    for (const name in interfaces) {
        for (const iface of interfaces[name]) {
            if (iface.family === 'IPv4' && !iface.internal) return iface.address;
        }
    }
    return '127.0.0.1';
}

// client.js
const zookeeper = require('node-zookeeper-client');

const client = zookeeper.createClient('127.0.0.1:2181');
const SERVICE_PATH = '/services/myapp';

client.once('connected', () => {
    console.log('Connected to ZooKeeper');
    watchServices();
});

client.connect();

function watchServices() {
    client.getChildren(
        SERVICE_PATH,
        event => {
            console.log('Service change event:', event);
            watchServices(); // 重新监听
        },
        (err, children) => {
            if (err) {
                return console.error('getChildren error:', err);
            }
            if (!children.length) {
                console.log('No Service available');
                return;
            }

            console.log('Found Services: ', children);

            children.forEach(child => {
                const fullPath = `${SERVICE_PATH}/${child}`;
                client.getData(fullPath, (err, data) => {
                    if (!err && data) {
                        console.log(`${child}: ${data.toString()}`);
                    }
                });
            });
        }
    );
}

// server.js
const zookeeper = require('node-zookeeper-client');
const os = require("os");

const client = zookeeper.createClient("127.0.0.1:2181");
const SERVICE_PATH = "/services/myapp";

client.once('connected', () => {
    console.log("Connected to ZooKeeper");
    registerService();
});

client.connect();

function registerService() {
    client.exists(SERVICE_PATH, (err, stat) => {
        if (err) {
            return console.error("exists error:", err);
        }
        if (!stat) {
            client.mkdirp(SERVICE_PATH, (err) => {
                if (err) {
                    return console.error("mkdir error:", err);
                }
                createEphemeralNode();
            });
        } else {
            createEphemeralNode();
        }
    });
}

function createEphemeralNode() {
    const ip = getLocalIP();
    const port = 3000 + Math.floor(Math.random() * 1000);
    const data = JSON.stringify({ ip, port });
    const nodePath = `${SERVICE_PATH}/node-`;

    client.create(nodePath, Buffer.from(data), zookeeper.CreateMode.EPHEMERAL_SEQUENTIAL, (err, path) => {
        if (err) return console.error("create error:", err);
        console.log(`Service registered at ${path} (${data})`);
    });
}

function getLocalIP() {
    const interfaces = os.networkInterfaces();
    for (const name in interfaces) {
        for (const iface of interfaces[name]) {
            if (iface.family === 'IPv4' && !iface.internal) return iface.address;
        }
    }
    return '127.0.0.1';
}

// client.js
const zookeeper = require('node-zookeeper-client');

const ZK_SERVERS = '127.0.0.1:2181';
const SERVICE_PATH = '/services/myapp';
let services = [];
let currentIndex = 0; // 用于轮询选择

const client = zookeeper.createClient(ZK_SERVERS);

client.once('connected', () => {
    console.log('Connected to ZooKeeper');
    watchServices();
});

client.connect();

// 监听服务节点变化
function watchServices() {
    client.getChildren(
        SERVICE_PATH,
        event => {
            console.log('Service list changed:', event);
            watchServices();
        },
        (err, children) => {
            if (err) return console.error('getChildren error:', err);
            if (!children.length) {
                services = [];
                console.log('⚠️ No available services.');
                return;
            }

            // 获取每个节点的数据
            const temp = [];
            let pending = children.length;

            children.forEach(child => {
                const fullPath = `${SERVICE_PATH}/${child}`;
                client.getData(fullPath, (err, data) => {
                    if (!err && data) {
                        temp.push(JSON.parse(data.toString()));
                    }
                    if (--pending === 0) {
                        services = temp;
                        console.log('🔍 Current available services:', services);
                    }
                });
            });

        }
    );
}

// 监听轮询负载均衡
function getNextService() {
    if (services.length === 0) {
        console.log('❌ No service available.');
        return null;
    }
    const service = services[currentIndex % services.length];
    currentIndex++;
    return service;
}

// 模拟客户端调用
setInterval(() => {
    const service = getNextService();
    if (service) {
        console.log(`Sendding request to ${service.ip}:${service.port}`);
    }
}, 2000);

const zookeeper = require('node-zookeeper-client');
const os = require('os');

const ZK_SERVERS = '127.0.0.1:2181';
const ELECTION_PATH = '/election';

const client = zookeeper.createClient(ZK_SERVERS);
let currentNodePath = null; // 当前节点路径

client.once('connected', () => {
    console.log('Connected to ZooKeeper');
    startElection();
});

client.connect();

// 创建选举节点
function startElection() {
    client.mkdirp(ELECTION_PATH, (err) => {
        if (err) {
            return console.error('mkdirp error:', err);
        }
        createElectionNode();
    });
}

function createElectionNode() {
    const nodePath = `${ELECTION_PATH}/node-`;
    const nodeData = Buffer.from(JSON.stringify({
        host: getLocalIP(),
        pid: process.pid,
    }));

    client.create(nodePath, nodeData, zookeeper.CreateMode.EPHEMERAL_SEQUENTIAL, (err, path) => {
        if (err) return console.error('create node error:', err);

        currentNodePath = path;
        console.log(`Created election node: ${path}`);
        checkLeader();
    });
}

// 检查自己是否是 Leader
function checkLeader() {
    client.getChildren(ELECTION_PATH, event => {
        console.log('Election node changed:', event);
        checkLeader(); // 重新检测
    }, (err, children) => {
        if (err) return console.error('getChildren error:', err);

        // 排序节点
        const sorted = children.sort();
        const myNode = currentNodePath.split('/').pop();

        if (sorted[0] === myNode) {
            console.log('I am the Leader!');
        } else {
            const leaderNode = sorted[0];
            console.group(`I am a Follower, current Leader: ${leaderNode}`);

            // 监听比自己小的那个节点（前一个节点）
            const myIndex = sorted.indexOf(myNode);
            const watchTarget = `${ELECTION_PATH}/${sorted[myIndex - 1]}`;

            client.exists(watchTarget, event => {
                console.log(`Watched node deleted: ${event}`);
                checkLeader(); // 前一个节点删除后重新检查
            }, (err, stat) => {
                if (err) return console.error('exist error:', err);
                if (!stat) checkLeader(); // 前一个节点被删除时重新检查
            });
        }
    });
}

function getLocalIP() {
    const interfaces = os.networkInterfaces();
    for (const name in interfaces) {
        for (const iface of interfaces[name]) {
            if (iface.family === 'IPv4' && !iface.internal) return iface.address;
        }
    }
    return '127.0.0.1';
}

/locks/mylock/lock-0000000001
/locks/mylock/lock-0000000002
/locks/mylock/lock-0000000003

const zookeeper = require('node-zookeeper-client');

const ZK_SERVERS = '127.0.0.1:2181';
const LOCK_PATH = '/locks/mylock';

const client = zookeeper.createClient(ZK_SERVERS);
let myNodePath = null;
let lockReleased = false;
let lockAcquired = false; // ✅ 防止重复获得锁

client.once('connected', () => {
    console.log('Connected to ZooKeeper');
    acquireLock();
});

client.connect();

function acquireLock() {
    client.mkdirp(LOCK_PATH, (err) => {
        if (err) return console.error('mkdirp error:', err);
        createLockNode();
    });
}

function createLockNode() {
    const nodePath = `${LOCK_PATH}/lock-`;
    client.create(
        nodePath,
        Buffer.from('lock-node'),
        zookeeper.CreateMode.EPHEMERAL_SEQUENTIAL,
        (err, path) => {
            if (err) return console.error('create error:', err);
            myNodePath = path;
            console.log(`🔒 Created lock node: ${path}`);
            checkLock();
        }
    );
}

function checkLock() {
    if (!myNodePath || lockReleased || lockAcquired) return;

    client.getChildren(
        LOCK_PATH,
        event => {
            if (!lockReleased && !lockAcquired) {
                console.log('📡 Lock node event:', event);
                checkLock();
            }
        },
        (err, children) => {
            if (err) return console.error('getChildren error:', err);
            if (!myNodePath || lockReleased || lockAcquired) return;

            const sorted = children.sort();
            const myNode = myNodePath.split('/').pop();
            const myIndex = sorted.indexOf(myNode);

            if (myIndex === 0) {
                lockAcquired = true; // ✅ 防止重复进入临界区
                console.log('✅ Lock acquired! I am the holder.');
                doCriticalSection();
            } else {
                const watchTarget = `${LOCK_PATH}/${sorted[myIndex - 1]}`;
                console.log(`⏳ Waiting for ${watchTarget} to be released...`);
                client.exists(
                    watchTarget,
                    event => {
                        if (!lockReleased && !lockAcquired && event.getType() ===
                            zookeeper.Event.NODE_DELETED) {
                            console.log('📢 Previous lock released, rechecking...');
                            checkLock();
                        }
                    },
                    (err, stat) => {
                        if (err) return console.error('exists error:', err);
                        if (!stat) checkLock(); // 前一个节点可能刚被删掉
                    }
                );
            }
        }
    );
}

function doCriticalSection() {
    console.log('🧠 Doing critical section...');
    setTimeout(() => {
        console.log('🧹 Releasing lock...');
        releaseLock();
    }, 5000);
}

function releaseLock() {
    if (!myNodePath || lockReleased) return;
    lockReleased = true;

    client.remove(myNodePath, (err) => {
        if (err) {
            if (err.code === zookeeper.Exception.NO_NODE) {
                console.warn('⚠️ Node already removed, safe to ignore.');
            } else {
                console.error('remove error:', err);
            }
        } else {
            console.log('🔓 Lock released!');
        }

        myNodePath = null;
        setTimeout(() => client.close(), 1000);
    });
}

// optimistic_lock.js
const zookeeper = require('node-zookeeper-client');

const ZK_SERVERS = '127.0.0.1:2181';
const PATH = '/optimistic/item';
const client = zookeeper.createClient(ZK_SERVERS);

client.once('connected', () => {
    console.log('✅ Connected to ZooKeeper.');
    // client.addAuthInfo('digest', Buffer.from('admin:admin123'));
    initNode(() => simulateClients());
});

client.connect();

// 初始化节点
function initNode(callback) {
    client.exists(PATH, (err, stat) => {
        if (err) return console.error('exists error:', err);
        if (stat) return callback();

        client.mkdirp('/optimistic', (err) => {
            if (err) return console.error('mkdirp error:', err);

            client.create(
                PATH,
                Buffer.from('stock=10'),
                zookeeper.CreateMode.PERSISTENT,
                (err) => {
                    if (err && err.getCode() !== zookeeper.Exception.NODE_EXISTS) {
                        return console.error('create error:', err);
                    }
                    console.log('🧱 Initialized node with stock=10');
                    callback();
                }
            );
        });
    });
}

// 模拟两个客户端同时修改库存
function simulateClients() {
    readAndUpdate('Client A', -1, () => {
        readAndUpdate('Client B', -2, () => {
            // 全部结束
            setTimeout(() => client.close(), 1000);
        });
    });
}

// 读取并尝试更新数据（带版本检查）
function readAndUpdate(clientName, delta, callback) {
    client.getData(PATH, (err, data, stat) => {
        if (err) return console.error(`${clientName} getData error:`, err);

        const stockStr = data.toString('utf8');
        const stock = parseInt(stockStr.split('=')[1]);
        const newStock = stock + delta;

        console.log(`${clientName} reads ${stockStr}, version=${stat.version}`);
        console.log(`${clientName} wants to update to stock=${newStock}`);

        // 尝试更新（使用当前 version）
        const newData = Buffer.from(`stock=${newStock}`);
        client.setData(PATH, newData, stat.version, (err, newStat) => {
            if (err) {
                if (err.getCode && err.getCode() === zookeeper.Exception.BADVERSION) {
                    console.error(`❌ ${clientName} update failed (version conflict).`);
                } else {
                    console.error(`${clientName} setData error:`, err);
                }
            } else {
                console.log(`✅ ${clientName} successfully updated! newVersion=${newStat.version}`);
            }
            callback();
        });
    });
}

// pessimistic_lock.js
const zookeeper = require('node-zookeeper-client');

const ZK_SERVERS = '127.0.0.1:2181';
const LOCK_PATH = '/locks/pessimistic';
const RESOURCE_PATH = '/pessimistic/resource';

const client = zookeeper.createClient(ZK_SERVERS);
let myNodePath = null;

client.once('connected', () => {
    console.log('✅ Connected to ZooKeeper.');
    client.addAuthInfo('digest', Buffer.from('admin:admin123'));
    ensurePaths(() => acquireLock());
});

client.connect();

// 确保锁目录和资源存在
function ensurePaths(callback) {
    client.mkdirp(LOCK_PATH, (err) => {
        if (err) return console.error('mkdirp lock error:', err);

        client.exists(RESOURCE_PATH, (err, stat) => {
            if (err) return console.error('exists error:', err);
            if (stat) return callback();

            client.mkdirp('/pessimistic', (err) => {
                if (err) return console.error('mkdirp resource error:', err);
                client.create(RESOURCE_PATH,
                    Buffer.from('value=0'),
                    zookeeper.CreateMode.PERSISTENT,
                    (err) => {
                        if (err && err.getCode() !== zookeeper.Exception.NODE_EXISTS)
                            return console.error('create resource error:', err);
                        console.log('🧱 Initialized resource: value=0');
                        callback();
                    });
            });
        });
    });
}

// 获取锁
function acquireLock() {
    const nodePrefix = `${LOCK_PATH}/lock-`;
    client.create(nodePrefix,
        Buffer.from('lock-node'),
        zookeeper.CreateMode.EPHEMERAL_SEQUENTIAL,
        (err, path) => {
            if (err) return console.error('create lock node error:', err);
            myNodePath = path;
            console.log(`🔒 Created lock node: ${path}`);
            checkLock();
        });
}

// 检查自己是否获得锁
function checkLock() {
    client.getChildren(LOCK_PATH, (err, children) => {
        if (err) return console.error('getChildren error:', err);
        const sorted = children.sort();
        const myNode = myNodePath.split('/').pop();
        const myIndex = sorted.indexOf(myNode);

        if (myIndex === 0) {
            console.log('✅ Lock acquired! Performing exclusive operation...');
            doCriticalSection();
        } else {
            const watchTarget = `${LOCK_PATH}/${sorted[myIndex - 1]}`;
            console.log(`⏳ Waiting for ${watchTarget} to be released...`);
            client.exists(watchTarget, event => {
                if (event.getType() === zookeeper.Event.NODE_DELETED) {
                    console.log('📢 Previous lock released, rechecking...');
                    checkLock();
                }
            }, (err, stat) => {
                if (err) return console.error('exists error:', err);
                if (!stat) checkLock();
            });
        }
    });
}

// 执行临界区操作
function doCriticalSection() {
    client.getData(RESOURCE_PATH, (err, data, stat) => {
        if (err) return console.error('getData error:', err);

        let value = parseInt(data.toString('utf8').split('=')[1]);
        console.log(`🔍 Read value=${value}`);

        // 模拟操作（加1）
        value++;
        const newData = Buffer.from(`value=${value}`);

        client.setData(RESOURCE_PATH, newData, stat.version, (err, newStat) => {
            if (err) return console.error('setData error:', err);
            console.log(`🧠 Updated resource to value=${value} (version ${newStat.version})`);

            // 模拟任务耗时
            setTimeout(() => {
                releaseLock();
            }, 3000);
        });
    });
}

// 释放锁
function releaseLock() {
    if (!myNodePath) return;
    console.log('🧹 Releasing lock...');
    client.remove(myNodePath, (err) => {
        if (err) {
            if (err.getCode && err.getCode() === zookeeper.Exception.NO_NODE) {
                console.warn('⚠️ Lock node already removed.');
            } else {
                console.error('remove error:', err);
            }
        } else {
            console.log('🔓 Lock released!');
        }
        client.close();
    });
}

const zookeeper = require('node-zookeeper-client');

const ZK_SERVERS = '127.0.0.1:2181';
const LOCK_ROOT = '/reentrant_lock';
const LOCK_NAME = 'mylock';
const CLIENT_ID = 'client-A';  // 模拟当前客户端唯一ID

const client = zookeeper.createClient(ZK_SERVERS);
client.connect();

let lockPath = null;
let reentrantCount = 0;

client.once('connected', async () => {
    console.log('✅ Connected to ZooKeeper');

    await ensurePath(LOCK_ROOT);
    await acquireLock();
    await acquireLock(); // 再次获取（测试可重入）

    setTimeout(async () => {
        await releaseLock();
        await releaseLock(); // 第二次释放才真正删除锁节点
        process.exit(0);
    }, 4000);
});

/**
 * 确保根路径存在
 */
function ensurePath(path) {
    return new Promise((resolve) => {
        client.exists(path, (err, stat) => {
            if (stat) return resolve();
            client.create(path, (err2) => {
                if (err2 && err2.getCode() !== zookeeper.Exception.NODE_EXISTS) {
                    console.error('❌ create path error:', err2);
                }
                resolve();
            });
        });
    });
}

/**
 * 尝试获取锁
 */
async function acquireLock() {
    if (lockPath) {
        reentrantCount++;
        console.log(`🔁 Re-entered lock (${reentrantCount} times)`);
        return;
    }

    const path = `${LOCK_ROOT}/${LOCK_NAME}`;
    try {
        lockPath = await createEphemeralNode(path, CLIENT_ID);
        reentrantCount = 1;
        console.log(`🔒 Lock acquired by ${CLIENT_ID}`);
    } catch (err) {
        if (err.code === zookeeper.Exception.NODE_EXISTS) {
            console.log(`⏳ Lock held by others, waiting...`);
            await waitForLock(path);
            return acquireLock(); // 重试
        } else {
            console.error('❌ acquire lock error:', err);
        }
    }
}

/**
 * 释放锁
 */
async function releaseLock() {
    if (!lockPath) return;
    reentrantCount--;
    console.log(`🧹 release lock called (${reentrantCount} remaining)`);

    if (reentrantCount === 0) {
        await deleteNode(lockPath);
        lockPath = null;
        console.log('🔓 Lock fully released');
    }
}

/**
 * 创建临时节点
 */
function createEphemeralNode(path, data) {
    return new Promise((resolve, reject) => {
        client.create(
            path,
            Buffer.from(data),
            zookeeper.CreateMode.EPHEMERAL,
            (err, createdPath) => {
                if (err) return reject(err);
                resolve(createdPath);
            }
        );
    });
}

/**
 * 删除节点
 */
function deleteNode(path) {
    return new Promise((resolve) => {
        client.remove(path, (err) => {
            if (err && err.getCode() !== zookeeper.Exception.NO_NODE) {
                console.error('remove error:', err);
            }
            resolve();
        });
    });
}

/**
 * 等待锁释放（监听删除事件）
 */
function waitForLock(path) {
    return new Promise((resolve) => {
        const watcher = (event) => {
            if (event.getType() === zookeeper.Event.NODE_DELETED) {
                console.log('📢 Lock node deleted, can retry.');
                resolve();
            } else {
                client.exists(path, watcher, () => { });
            }
        };
        client.exists(path, watcher, () => { });
    });
}