Scene 07

Sentinel — quorum detects, majority elects

Sentinels reach ODOWN at quorum agreement but require a strict majority to elect a failover leader, and Sentinel does not stop the partitioned old master from accepting writes — that is the data plane's job.

Previously

Replicas hold a copy, but they don't decide on their own when to take over. Sentinel is the small, separate process that watches, votes, and promotes.

Scene 07

Sentinel — quorum detects, majority elects

Watch
Try it
Predict
Capture

What to watch for

Three Sentinels watch one master and a replica. The master crashes; watch SDOWN turn into ODOWN once quorum agrees, then a vote in epoch 1 elects the leader who promotes the replica.

Implementation

Highlighted lines are the ones running in the diagram right now.

Sentinel.tick

periodic: detect SDOWN locally, escalate to ODOWN at quorum

1def tick(self):
2    if not master.responds_within(down_after_ms):
3        self.mark_sdown()  # local opinion only
4    # ask peers via SENTINEL is-master-down-by-addr
5    odown_agree_count = 1 + sum(
6        1 for peer in peers if peer.thinks_sdown(master)
7    )
8    if odown_agree_count >= quorum:
9        self.status = ODOWN  # quorum-agreed
10        self.start_election()

Sentinel.startElection

bump epoch, broadcast a vote request, collect peer votes

1def start_election(self):
2    if self.status != ODOWN:
3        return
4    self.my_epoch += 1  # fence this round
5    self.vote_for = self.id
6    broadcast(VoteRequest(
7        candidate = self.id,
8        epoch = self.my_epoch,
9    ))
10    self.tally = collect_votes_from_peers(
11        epoch = self.my_epoch,
12    )

Sentinel.tallyVotes (majority required)

ODOWN used quorum; election uses majority — different counters

1def tally_votes(self):
2    majority = (sentinel_count // 2) + 1  # NOT quorum
3    if max(self.tally.values()) >= majority:
4        winner = argmax(self.tally)
5        promote(replica)  # SLAVEOF NO ONE
6        return
7    if all_voted_and_no_majority(self.tally):
8        self.state = TIED
9        retry_in(2 * failover_timeout)  # bumps epoch

Sources

Where this sits in Build Redis

Scene 07 of 10, in the HA act — Replication and Sentinel — async by design.. SDOWN/ODOWN ladder, epoch-based election, and the operator footgun: quorum ≠ majority.

Up next. Cluster — Sentinel keeps one master and its replicas available. But you still only have one master's worth of write throughput. Cluster is how you get more.

All 10 scenes in Build Redis · Every curriculum

Designs that use this

Built with Arqly

Every scene in Build Redis builds on the one before it.All 10 Build Redis scenes