summaryrefslogtreecommitdiffstats
path: root/docs/guides/federation/proposing-and-voting.md
Commit message (Collapse)AuthorAgeFilesLines
* federation: revisions shown, named, and moved to by handtv18 hours1-0/+3
| | | | | | | | | | | | | | | | | An operator moving the federation to a revision had nothing to say which revisions a node knows, nor which one the current version follows, and a hash where a name would do. `GET /events` lists the revisions the node's continuum knows, each its number, its ID, the feature it adds and what that adds, and as people read it ("revision 1 (merge-events)"); `GET /events/counts`, the current version's. `continuum-party next --revision FEATURE` begins a version following the revision adding it, never an earlier one than the current version's, and `next` says so where the node knows a later one. `proposals` shows a change of revision as people read it, a revision this continuum doesn't know so said. A client backs a version moving to a revision only where its node knows it, and says why otherwise: once passed, a node that doesn't stops there. The upgrades guide walks through moving to a revision: upgrade every node, propose, vote, and what follows; the proposing guide lists `revision`, and the API's spec the rest.
* continuum-party: warns before a true that only every nay left endstv20 hours1-0/+6
| | | | | | | | A `true` holds its party until its proposal passes or is dead, and only other parties' nays make it dead: where the parties yet to vote are too few, one of them staying quiet binds the party on that version for good. The client says so before it casts such a `true` (`client::binding`): where ending the proposal would take every party yet to vote, or more, and those are a third of the parties or fewer.
* federation: a checkpoint of 64 heads at most, a version of 96 partiestv20 hours1-15/+15
| | | | | | | | | | | 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 headstv20 hours1-1/+2
| | | | | | | | | | | | | | | 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`).
* events: why no party's client backs a proposaltv26 hours1-6/+8
| | | | | | | | | | | | `GET /events/counts` gives each proposal on the current version `none`: why a party's client backs it not (`client::backable`), where it is no version as this node reads it, none changing the current one, or one naming the heads of the current one's checkpoint; else `null`. So a node shows that a proposal is none, and why, before it passes: one that passes all the same is never written, or, no version here, the node stops at its version event. The dashboard shows it with the proposal, and `continuum-party proposals` says it by the federation the client knows. Row 48's test checks what a node shows of the proposal.
* federation: a node stops at a version it doesn't readtv26 hours1-1/+4
| | | | | | | | | | | | | | | | | | | | | | A version event writing a proposal passed on the version a node reads, which doesn't read as a version there (of a later federation, using what a later continuum takes, or none at all), the node can't judge: `Fold::stops`. The store stops at it: it takes nothing and refuses nothing from then on, holding back whatever comes, that event first (`Offered::Stopped`), and keeps none of it across a restart, where it stops there again. One beside the version the node reads is refused of its own, as any other. Its operator has it drop that event (`POST /admin/events/drop`), or one it builds on: it is refused as dropped, or as built on what was, any version event writing that version with it, kept in the store file; the node judges what it held back and goes on under the version before. Allowed again, it stops there once more. The node logs the stop and its end; `GET /events` names the event, why, and how many it holds back (`stopped`); a put answers `stopped`, written into the document all the same; a node voting by itself casts nothing while stopped. The test fold's eras tagged `new` stop a store. Row 39 is tested (`federation_attack_39`); of rows 9, 10 and 48, a node stops at the version event.
* docs: references to another document's section linked to ittv33 hours1-8/+11
| | | | | | | | Where a document names a section of another after linking to it ("([`store.md`](store.md), Pinned checkpoints)"), the name links to that section too, by the id both GitHub and cgit's about filter give its heading; paragraphs that grew past the width are wrapped anew, links and code kept on one line each.
* docs: references to a section of the same document linked to ittv33 hours1-2/+3
| | | | | | | | Where a document names one of its own sections in parentheses ("(What counts, 5)", "(Joining, below)"), the name links to the section by its GitHub-style ID; paragraphs that grew past the width are wrapped anew, links and code kept on one line each. References to another document's sections stay as they are.
* continuum-party: proposes only what a party may backtv33 hours1-3/+6
| | | | | | | | | One check (`client::backable`) decides what a party's client proposes and what it votes `true` on: a version, changing the current one as a version must, whose checkpoint, where it names one, names none of the heads of the current version's checkpoint, as a version naming those again is never written. A proposal nobody may back is refused before it is signed, saying why.
* continuum-party: votes and proposals checked for the key a version namestv34 hours1-1/+2
| | | | | | A vote or a proposal is signed with a key the current version names for the party, as a key set and a node list are: the client checks it before it signs, and records nothing where the key isn't one.
* continuum-party propose: the proposal's hash, and --yestv34 hours1-0/+5
| | | | | `propose` says the proposal's hash, the version's, which `vote` takes; with `--yes`, it votes `true` on it too, by the record, as `vote` does.
* continuum-party propose: only a version changing the current onetv34 hours1-2/+4
| | | | | | The client proposes a version only where it changes the current one as a version must (its number, the hash it names, each `since`), and says why it doesn't otherwise: no other can pass.
* continuum-party next: the version after the current one, to changetv34 hours1-4/+4
| | | | | | | `next` prints the current version numbered on, naming its hash as the version it changes, and without the checkpoint it names, whose heads are behind: what a party changes and proposes. The guides begin a version with it.
* guides: a party writes its node list without a votetv34 hours1-5/+10
| | | | | | | Where a reader adding a node looks (getting started, proposing a version, who syncs), the guides say that a party writes its node list itself, signed with a key its version names, and link to how; a version names a list anew only where its party can't.
* dashboard: the federation, in a swarm holding a storetv2 days1-0/+3
| | | | | | | | | | | | | | In a swarm holding a store, the snapshot names the node's party, and the document box shows what counts as the node reads it, read every 5 s: the current version, the parties with their keys and nodes, the rules, the values at places as a tree with who writes there, the proposals on the version with where each stands, who voted what and what its version changes, and what the node refused. `document` beside `remake…` shows the document underneath. Where the node votes for its party by itself, a proposal that can still pass has a vote of each kind, cast through the node on a second click. The page writes no values: a party signs its writes with its key.
* continuum-party proposals: where each proposal stands, and what it changestv2 days1-0/+11
| | | | | | | | `continuum-party proposals` lists the proposals on the current version at the node, each with whether it passed or is dead and the parties voting `true` and `false`, as `GET /events/counts` names them, and what its version changes of the current one, read from an event proposing it, its signature checked: each field whose value differs, and of `keys` and `nodes` each party's (`client::changes`).
* events: counts names who voted what, and whether a proposal passed or is deadtv2 days1-3/+17
| | | | | | | | `GET /events/counts` gives each proposal on the current version the parties voting `true` and `false` (`yes`, `no`), whether it passed and whether it is dead (`passed`, `dead`), as the node reads its votes (`State::tally`, which the fold judges by too), so that reading where a vote stands takes no fetch of every vote. A party's client still decides its votes by the votes it checks itself.
* guides: a version begun from the current one leaves out its checkpointtv2 days1-1/+3
| | | | | | The current version may name a checkpoint, whose heads are behind: a version naming them again is never written. Writing a version leaves it out unless the version moves the store on.
* guides: proposing and voting in a federationtv2 days1-0/+116
Writing a version from the current one, its `since`s and what makes one none, proposing it, voting through the party's client by its record and what the client refuses to cast, voting through a node that votes for its party, a lost record, and when a proposal passes or dies, with the counts for some numbers of parties.