Database Scalability and High Availability Questions

import bisect, hashlib

def hash_fn(s):                              # deterministic 32-bit hash
    return int(hashlib.md5(s.encode()).hexdigest(),16) % (2**32)

class ConsistentHashRing:
    def __init__(self, vnode_factor=100):
        self.vnode_factor = vnode_factor     # base virtual nodes per weight unit
        self.ring = []                       # sorted list of hashes
        self.hash_to_node = {}               # hash -> node_id
        self.node_vnodes = {}                # node_id -> list of vnode hashes

    def add_node(self, node_id, weight=1):
        vcount = max(1, int(self.vnode_factor * weight))
        vhashes = []
        for i in range(vcount):
            h = hash_fn(f"{node_id}#vn{i}")
            # avoid collision: linear probe with suffix
            j = 0
            while h in self.hash_to_node:
                h = hash_fn(f"{node_id}#vn{i}#{j}")
                j += 1
            bisect.insort(self.ring, h)
            self.hash_to_node[h] = node_id
            vhashes.append(h)
        self.node_vnodes[node_id] = vhashes

    def remove_node(self, node_id):
        for h in self.node_vnodes.get(node_id, []):
            idx = bisect.bisect_left(self.ring, h)
            if idx < len(self.ring) and self.ring[idx] == h:
                self.ring.pop(idx)
            self.hash_to_node.pop(h, None)
        self.node_vnodes.pop(node_id, None)

    def get_node(self, key):
        if not self.ring: return None
        h = hash_fn(key)
        idx = bisect.bisect_right(self.ring, h)
        if idx == len(self.ring): idx = 0
        vnode_hash = self.ring[idx]
        return self.hash_to_node[vnode_hash]