Scalable System Architecture and Design Principles Questions

import hashlib
import bisect

def _hash(value: str) -> int:
    return int(hashlib.md5(value.encode()).hexdigest(), 16)

class ConsistentHashRing:
    def __init__(self, replicas=100):
        self.replicas = replicas
        self.ring = []            # sorted list of vnode hashes
        self.hash2node = {}       # map vnode hash -> node id
        self.nodes = set()

    def AddNode(self, node_id: str):
        if node_id in self.nodes: 
            return
        self.nodes.add(node_id)
        for i in range(self.replicas):
            vnode_key = f"{node_id}:{i}"
            h = _hash(vnode_key)
            bisect.insort(self.ring, h)
            self.hash2node[h] = node_id

    def RemoveNode(self, node_id: str):
        if node_id not in self.nodes:
            return
        self.nodes.remove(node_id)
        remove_hashes = [h for h, n in self.hash2node.items() if n == node_id]
        for h in remove_hashes:
            idx = bisect.bisect_left(self.ring, h)
            if idx < len(self.ring) and self.ring[idx] == h:
                self.ring.pop(idx)
            del self.hash2node[h]

    def GetNode(self, key: str) -> str|None:
        if not self.ring:
            return None
        h = _hash(key)
        idx = bisect.bisect(self.ring, h)
        if idx == len(self.ring):
            idx = 0
        vnode_hash = self.ring[idx]
        return self.hash2node[vnode_hash]

# Basic unit-test style assertions
if __name__ == "__main__":
    ring = ConsistentHashRing(replicas=10)
    ring.AddNode("A"); ring.AddNode("B"); ring.AddNode("C")
    assignments1 = {k: ring.GetNode(k) for k in ["alpha","beta","gamma","delta","epsilon"]}
    # Remove a node and check only subset moved
    ring.RemoveNode("B")
    assignments2 = {k: ring.GetNode(k) for k in assignments1}
    moved = sum(1 for k in assignments1 if assignments1[k] != assignments2[k])
    assert moved < len(assignments1)  # most keys remain on same node
    # Add back and ensure mapping stabilizes (idempotence)
    ring.AddNode("B")
    assignments3 = {k: ring.GetNode(k) for k in assignments1}
    assert any(assignments3[k] == assignments1[k] for k in assignments1)