From f85298c40c2528ee801c14a10a7db8920b50fdf8 Mon Sep 17 00:00:00 2001 From: tv Date: Thu, 19 Nov 2026 14:09:05 +0000 Subject: vote: the version that moved the store counts not toward the next checkpoint `--store-propose-versions` counted the versions since the checkpoint's version, the one current at its heads. The version that moved the store there is written after its heads, so it counted: with 1, a node proposed a checkpoint again as soon as it backed one (`--store-back-after` after the move), and the next one, and so on, every ten minutes for good. It counts the versions written since that change more than moving to a checkpoint now (`State::changed_since_checkpoint`): with 1, one checkpoint after every other version, and none after a checkpoint. The test goes on past the move. --- src/config/mod.rs | 2 +- src/federation/fold.rs | 18 +++++++++++++++--- src/federation/vote.rs | 14 ++++++++++++-- 3 files changed, 28 insertions(+), 6 deletions(-) (limited to 'src') diff --git a/src/config/mod.rs b/src/config/mod.rs index 3b8d305..caecb49 100644 --- a/src/config/mod.rs +++ b/src/config/mod.rs @@ -310,7 +310,7 @@ pub(crate) const OPTIONS: &[OptionSpec] = &[ Kind::Integer, "COUNT", None, - "With store-vote-key: propose a checkpoint, as store-propose-events, once this many versions were written since its store's checkpoint: with 1, after every version, so that what keys voting twice could grow beside it at a history from before ends there.", + "With store-vote-key: propose a checkpoint, as store-propose-events, once this many versions changing more than moving to a checkpoint were written since its store's checkpoint: with 1, after every such version, so that what keys voting twice could grow beside it at a history from before ends there.", ), #[cfg(feature = "federation")] option( diff --git a/src/federation/fold.rs b/src/federation/fold.rs index d832976..46dad27 100644 --- a/src/federation/fold.rs +++ b/src/federation/fold.rs @@ -350,9 +350,21 @@ impl State { ballots } - /// The checkpoint's version: the one current where the store moved there, or started. - pub(crate) fn checkpoint_version(&self) -> &Version { - &self.versions[&self.checkpoint] + /// How many versions were written since the checkpoint's that change more than moving + /// to a checkpoint: the one that moved the store there counts not. + pub(crate) fn changed_since_checkpoint(&self) -> u64 { + let mut count = 0; + let mut version = self.current(); + while version.hash != self.checkpoint { + let Some(before) = version.changes.and_then(|hash| self.versions.get(&hash)) else { + break; + }; + if !version.only_moves_on(before) { + count += 1; + } + version = before; + } + count } /// The version the proposal of hash `proposal` proposes, as JSON, where it holds one: diff --git a/src/federation/vote.rs b/src/federation/vote.rs index 4ba2e8f..7000b40 100644 --- a/src/federation/vote.rs +++ b/src/federation/vote.rs @@ -49,7 +49,8 @@ pub(crate) struct Rules { pub(crate) propose_events: Option, /// ...or so long after the store moved to it, by its own clock... pub(crate) propose_every: Option, - /// ...or once so many versions were written since the one it holds. + /// ...or once so many versions were written since the one it holds, of those changing + /// more than moving to a checkpoint. pub(crate) propose_versions: Option, /// How long it holds an event before it holds it for a while: the voters' rule, and how /// long a new proposal holds back a checkpoint. @@ -421,7 +422,7 @@ pub(crate) fn by_hand( /// what is written after does. fn checkpoint(seen: &Seen<'_>, rules: &Rules, current: &Version, all: &[Proposed]) -> Option { let store = seen.store; - let since = current.number - store.state().checkpoint_version().number; + let since = store.state().changed_since_checkpoint(); let due = rules .propose_events .is_some_and(|events| store.taken().len() >= events) @@ -836,6 +837,15 @@ mod tests { let version = Version::read(json).unwrap(); assert_eq!(version.checkpoint, Some(vec![written])); assert_eq!(version.changes, Some(next.hash())); + // Once the store moved there, the version that moved it counts not: none again. + let on = next.hash(); + let proposal = taken(&mut store, tv.propose(&[written], json)); + let votes = [&tv, &lass] + .map(|party| taken(&mut store, party.vote(&[proposal], on, version.hash, true))); + taken(&mut store, harness::version_event(&votes, version.hash)); + assert_eq!(store.state().current().hash, version.hash); + assert_eq!(store.state().changed_since_checkpoint(), 0); + assert!(decide(&seen(&store, &long), &rules, &record).is_empty()); } /// A node proposes a checkpoint at the heads its store holds, the one it took a moment -- cgit v1.3.1