Quick POC for "distributed lock" using ZooKeeper

step-by-step POC for distributed locking using ZooKeeper. Simulate two clients competing for a lock (e.g., accessing a shared resource like a database).

---

Step 1: Start ZooKeeper

brew install zookeeper
zkServer start

---

Step 2: Create a Lock Path

Terminal 1:

zkCli.sh
create /locks "locks"  # Persistent parent node for locks

---

Step 3: Simulate Client 1 Acquiring the Lock

Terminal 1:

create -e -s /locks/lock_ "client1"  # Create ephemeral + sequential node

Output: Created /locks/lock_0000000000

• Check if it’s the smallest node:

    ls /locks
  
    Output: [lock_0000000000]
  

  • Since there are no other nodes, Client 1 holds the lock.

---

Step 4: Simulate Client 2 Trying to Acquire the Lock

Terminal 2:

zkCli.sh
create -e -s /locks/lock_ "client2"  # Create ephemeral + sequential node

Output: Created /locks/lock_0000000001

• Check if it’s the smallest node:

    ls /locks
  
    Output: [lock_0000000000, lock_0000000001]
  

  • Client 2 is NOT the leader (its sequence number is larger).

• Set a watch on the previous node:

    stat /locks/lock_0000000000 true  # `true` enables a watch
  

  • Client 2 waits for lock_0000000000 to be deleted.

---

Step 5: Simulate Client 1 Releasing the Lock

Terminal 1:

1. Delete the lock node (simulating releasing the lock):

    delete /locks/lock_0000000000
   

2. Exit the CLI (optional):

    quit
   

---

Step 6: Observe Client 2 Acquiring the Lock

Terminal 2:

• The watch on lock_0000000000 triggers:

    WatchedEvent state:SyncConnected type:NodeDeleted path:/locks/lock_0000000000
  

• Client 2 checks if it’s now the smallest node:

    ls /locks
  
    Output: [lock_0000000001]
  

  • Client 2 now holds the lock.

---

Step 7: Simulate Client Failure

Terminal 2:

1. Press Ctrl+C to terminate the CLI session.

2. The ephemeral node /locks/lock_0000000001 is automatically deleted.

---

Concepts

1. Ephemeral + Sequential Nodes:

   • Clients create ordered nodes to compete for the lock.

   • The smallest sequence number wins.

2. Watches:

   • Clients watch the node immediately before their own in the sequence.

   • If that node is deleted (lock released), they recheck for leadership.

3. Atomic Operations:

   • create -s ensures sequential numbering.

   • delete ensures the lock is released cleanly.

---

How This Maps to Real-World Systems

• Use Case: Managing access to a shared resource (e.g., a database, file, or API).

• Behavior:

  • Clients acquire the lock by creating the smallest ephemeral node.

  • If a client crashes, its node is deleted, and the next client takes over.

---

Summary

This POC mirrors how distributed systems like Hadoop or Kafka manage resource contention. 🚀