aboutsummaryrefslogtreecommitdiffstats
path: root/src/federation/vote.rs
Commit message (Collapse)AuthorAgeFilesLines
* federation: a checkpoint of 64 heads at most, a version of 96 partiestv25 hours1-1/+5
| | | | | | | | | | | No event is above more heads than it may name dependencies (64): a version naming more for its checkpoint is never written. A node voting by itself proposed one at whatever heads it held for a while, however many; it now proposes none past 64, as what is written merges them, and a party's client backs none such (`client::backable`). A version event names the votes passing a proposal, two thirds of its version's parties: past 96 parties, more than an event may name. A version names at most 96 now (`version::PARTIES`).
* federation: votes on the events proposing a checkpoint above its headstv25 hours1-2/+12
| | | | | | | | | | | | | | | Anyone could propose a checkpoint's version again, by an event beside its heads. A node voting by itself, and a party's client, built a vote on every event proposing what it voted on, so every vote was beside the heads, and no version event written on them was taken: the checkpoint could never move the store. And the voters' rule refused it once that event was held for a while, as the heads left it out. They vote on the events proposing it that are above the heads it names (`State::proposing`), which `GET /events/counts` lists as `proposals`; where there are none, `none` says so, the node casts nothing and the client says why. The voters' rule leaves proposals and votes aside, as they lapse with the move. Row 70 is tested (`federation_attack_70`).
* attacks: rows 45, 58 and 65 tested beside the code they testtv34 hours1-0/+48
| | | | | | | | | | | The check that every attack row of the federation has its test looks beside the code a row is about too: a node's (`held`), a party's client's (`client`), and a node voting by itself (`vote`). Rows 45 (a version written on the side a node doesn't read, refused as its own and reported apart, the change that put it taken), 58 (a node following on checkpoints only, unless its operator chose any version) and 65 (a client keeping the nays that freed its `true`) have their tests there, and wait no more.
* federation: a rule voting `false` on a checkpoint proposed beside one a node ↵tv3 days1-0/+141
| | | | | | | | | | backs `--store-nay-beside`, for a node voting by itself: where its party backs a proposal on the current version that can still pass, by its record or by what it votes now, it votes `false` on every other proposal there that only moves to a checkpoint and can still pass, once. So, of two checkpoints proposed at once, the one it doesn't back dies, and its backers are free (`docs/federation.md`, Votes a node casts by itself).
* federation: what a node voting by itself decidestv3 days1-0/+513
A party may have one of its nodes vote and propose for it, by rules its operator sets (`docs/federation.md`, Votes a node casts by itself): `federation::vote::decide`, from the node's store, how long it held each event, and its party's record. * Following: `true` on a proposal on the current version where a party it follows voted `true`, `false` where one voted `false`; by default only on a version that only moves to a checkpoint, a `true` as a `false`. * Proposing a checkpoint: once so many events are held beyond its checkpoint, or so long after the store moved there, a version that only moves to a checkpoint at the heads of what it held for a while, at which the current version is current; only where nothing that can still pass is proposed on the current version, but a proposal it wouldn't back that nobody backs but its proposer. It backs what it proposes. It keeps to what a party's client keeps to (`Record::may_vote`), one `true` at a time; and by the voters' rule (`vote::backs_checkpoint`) backs a version naming a checkpoint only where it changes nothing of the current one but its number, what it changes and its checkpoint, and its heads leave out nothing it held for a while before it was proposed. A party that has a node vote by itself votes by hand only through that node, which keeps its one record: `vote::by_hand` decides such a vote by the record and, with a `true`, by the voters' rule.