Ring Topology

Imagine five database nodes arranged in a circle. Node A replicates to Node B, B replicates to C, C to D, D to E, and E back to A. Every node has exactly one upstream and one downstream. Clean. Symmetric. Balanced.

Ring topology was popular in the early days of distributed databases, particularly in multi-master setups where any node could accept writes. Apache Cassandra's earliest versions used a ring for data distribution. Token Ring networking (IEEE 802.5) ran many enterprise LANs in the 1980s and 1990s before Ethernet killed it. IBM's mainframe clustering relied on ring communication for decades.

The appeal is obvious: no single node bears the full replication burden. Each node only replicates to one neighbor, so the load is evenly distributed. In a star topology, the primary replicates to all replicas simultaneously. In a ring, each node only replicates to the next one in the chain.

But ring topology has a fatal flaw that's made it largely obsolete for most database replication use cases. We'll get to that.

Each node in the ring receives data from its predecessor and forwards it to its successor:

1. Node A writes data and sends it to Node B
2. Node B applies the change and forwards it to Node C
3. Node C applies and forwards to Node D
4. This continues around the ring until the originating node receives its own write back (and discards it to prevent infinite loops)

Change propagation through the ring takes N-1 hops for N nodes. In a 5-node ring, a write on Node A takes 4 hops to reach Node E. Each hop adds latency: network transfer time plus the receiving node's apply time. If each hop takes 5ms, the farthest node is 20ms behind the writer. In a 10-node ring, that becomes 45ms.

Loop prevention relies on originator IDs. Each write carries the node ID of the original writer. When a node receives a write that it originally sent, it discards it instead of forwarding again. Without this, a single write would circle the ring forever.

Conflict detection uses timestamp-based last-write-wins or version vectors. Each write carries an originator ID and timestamp. Nodes that receive a change check if they've already seen a newer write for the same key and skip it if so.

Propagation delay grows linearly with the number of nodes. This is manageable for small rings but becomes a real consistency problem at scale. A 20-node ring means the farthest replica is nearly 100ms behind the writer.