aboutsummaryrefslogtreecommitdiffstats
path: root/docs/guides
Commit message (Collapse)AuthorAgeFilesLines
* federation: revisions shown, named, and moved to by handtv19 hours3-11/+72
| | | | | | | | | | | | | | | | | 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.
* vote: a node proposes a checkpoint at the heads it holdstv19 hours2-10/+12
| | | | | | | | | | | | | | | | A node proposed a checkpoint at the heads of what it held for a while: every event written in that while, and every one built on an event beside those heads, as one party writing now and then on something old makes them, was beside them, and refused once the store moved. A voter whose while was shorter backed none, one whose while was longer backed it and lost those. It proposes at the heads its store holds, sorted: what was written before is in their history, and only what is written while the vote takes its course may be beside them. It proposes none where they are more than an event may name: under a revision with merge events, it merges them first; otherwise, what is written after does. `--store-held-for` keeps the voters' rule and how long a new proposal holds back a checkpoint. `federation.md`, the guides and the options say so.
* held: a node merges its store's heads beyond what an event may nametv19 hours2-2/+7
| | | | | | | | | | | | | | | Past 64 heads, no event is above them all, and what is written builds on the earliest 64 alone: where nobody writes, heads apart stay apart, and a checkpoint naming them is never written. Under a revision with merge events, a node its party lists signs merge events with its node key where its store holds more heads than an event may name, each on as many as it may, the earliest taken first, until no more are left (`Holding::merge`). The worker does so a random wait after the heads first were too many, as it puts again what the document lacks, so that of the members few do at once. `federation.md` says so under Nodes, and the guides say what a node writes by itself and what its log says.
* federation: merge events, the first revisiontv19 hours1-1/+2
| | | | | | | | | | | | | | | | | | What builds on many heads merges them, but only an event a party writes: in a quiet federation, heads beside each other stay so, and past 64 no event is above them all. Revision 1 (`merge-events`) adds merge events: `{"merge": true}`, signed with a node's own key, the `key` its Ed25519 key, for the party whose node list names it. One counts for nothing, and only gathers what it builds on into the history of what builds on it. Under the base revision, signed by a node its party doesn't list, or by a party's key, it is refused; the model alike. Generated federations begin at either revision, and their nodes merge. A node voting by itself backs no version changing the revision, on any version neither: its party's operators vote on that one, once their nodes run a continuum that knows it. `federation.md` lists the revisions, says what a merge event is, and row 71 is tested (`federation_attack_71`).
* federation: a version names the revision of federation 1 it followstv19 hours3-24/+23
| | | | | | | | | | | | | | | | | | What every node must agree on was named by the federation's number alone, and a change that only took more kept it: a party could use it before every node ran it, and nodes not upgraded refused what followed and parted from the others. A version now names the revision it follows by its ID (`"revision": "<ID>"`), the SHA-256 of the JCS list of the features it adds to the base revision federation 1 began with (`federation::revision`); a version naming none follows the base revision, ECDSA keys among it, so the versions written so far read as they did. A version names the base revision only by leaving `revision` out, and a revision no earlier than the one of the version it changes. A continuum that doesn't know a revision, another build's among them, can't read a version naming it: it stops at a version event writing one, and says which revision and what it knows. There are no revisions yet but the base revision. `federation.md` says how a revision is rolled out, then passed, and what a later continuum may leave out; the upgrades guide, and the one on a node stopped, alike.
* docs: quiet parties, proof of voting twice, the next change keeping the numbertv21 hours3-4/+10
| | | | | | | | | | | | | | From the red-team review of the design: * a party that never votes holds those backing a proposal short by as many votes: they can neither pass it nor back another, a compromise all others would pass among them; `federation.md` draws that out, and the promises guide says so; * a client keeps its own votes and the nays that freed it, not another party's two: where keys voted twice, whoever saw it keeps the votes naming the party before a checkpoint leaves them out; * nothing but agreement keeps a party from using a change that keeps the federation's number before every node runs it: the next such change names itself in the version, so that two thirds decide when, and a node not running it stops at that version.
* continuum-party: warns before a true that only every nay left endstv21 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.
* vote: propose a checkpoint after so many versionstv21 hours2-14/+19
| | | | | | | | | | | | | | The votes cast before count at a history from before too: a proposal that died, or a rival, needs there only the votes it lacked, and after a close vote one key voting twice is enough, at any time until a checkpoint above the version that followed. Nodes that took that version refuse it; one lagging behind, or joining from the root, may take it. `federation.md` said it took the keys of two thirds of the parties. A node voting by itself proposes a checkpoint once so many versions were written since its store's (`--store-propose-versions`), as the design lists: with 1, after every version, so that what keys voting twice grow beside a version ends at a checkpoint above it. `federation.md` says how little a rival version takes, row 20 too, and the guides the option.
* vote: a proposal holds back checkpoints by a third, or new for a whiletv21 hours2-8/+13
| | | | | | | | | | | | | | | A node voting by itself proposes no checkpoint beside a proposal that holds it back, as the checkpoint would lapse it, and a follower backs none so. A proposal held one back where someone but its proposer backed it: two parties, or one and a stolen key, kept a junk proposal alive, and no automatic checkpoint came while it lived, ending it taking nays from more than a third each round. And one new, its proposer alone backing it, was lapsed at once by a checkpoint its writes brought about. A proposal that can still pass holds back now where a third of the parties back it, someone but its proposer among them; or where it is new, held for less than a while (`--store-held-for`), and its proposer has none older on the version: so it is heard before a checkpoint lapses it, once a version for each proposer. Row 67 says so, and a test of nine parties checks it.
* vote: a follower copies no false, lapses nothing others back, waits after a movetv21 hours2-7/+15
| | | | | | | | | | | | | | | | | | | A node following a party (`--store-follow`) handed it more than the text said: * it copied the party's `false`: one party's nay freed bound followers, and its `true` shown to some and its `false` to the rest passed a checkpoint at one history and made it dead at another. It copies the `true` alone now, on any version too; * a checkpoint lapses every other proposal: the followed party ended any proposal it disliked by passing one. A node follows a checkpoint only where no proposal that changes more can still pass that someone but its proposer backs; * nothing bounded how often the store moved, so fresh events could be left out of every checkpoint; and a node just started held nothing for a while, so the voters' rule kept nothing. A node backs, and proposes, a checkpoint only once its store held its checkpoint, or ran, for a while (`--store-back-after`, ten minutes unless set), by itself or by hand. `federation.md` says what following hands over, and row 58 what a follower on any version copies; the guides and the example say the rest.
* federation: a checkpoint of 64 heads at most, a version of 96 partiestv21 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 headstv21 hours3-11/+14
| | | | | | | | | | | | | | | 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 proposaltv27 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.
* version: say why a version is nonetv27 hours1-2/+8
| | | | | | | | | | | | `Version::read` names what makes a version none: the field it lacks, or the one more it has, that this continuum doesn't know (of the version, a party's keys or node list, a rule), the federation it names beside the one this continuum knows, how many keys or nodes a party has against how many it may, the node ID that is none, and of a key why it is none (`keys::spelled`): its type, its point, or its spelling. A node that stops at a version says so in `stopped` (`GET /events`) and its log; a party's client in what it won't propose or back. The guide to a node that stopped says what `why` tells.
* store: a stopped node leaves out none of what it holds backtv27 hours1-1/+4
| | | | | | | | | | | | | | | A store that stopped can't tell which of what it holds back will be taken, nor which of what waits: `Store::held_back` gives both, each after what it builds on. A node leaves out none of it: it puts it again where its document lacks it (`Holding::lacking`), a remake's snapshot holds it (`Holding::at_base`), and after a switch or a rejoin it puts again what of it the document it left held (`Holding::left`). A remake while nodes are stopped no longer drops what was put since the stop, nor the event they stopped at. Tested: a node keeps what it holds back, what waited among it, through a snapshot, and a store read anew from that stops there again; and a simulation: a swarm stopped at a version compacts, a node away meanwhile rejoins and one started again with nothing reads the new epoch, each stopping there, holding back what came after, until their operators have them drop that event.
* federation: a joining node takes the first of two versions, as any nodetv28 hours2-4/+9
| | | | | | | | | | | | Of two versions changing the one it reads, a node takes the first it judges, joining or not, and reports the other: its operator chooses, by dropping and allowing. No rule holds a joining node back until it has synced with every seed: it learns of the other members as it syncs, and its seeds may go away. federation.md drops the joining rule from Changing the policy, and says so in what isn't promised and in row 63; the guides say what a joining node takes. Row 63 is tested (`federation_attack_63`): from the root, either side first, the operator switching sides; and pinned at a later checkpoint, the chain old keys grew never taken.
* dashboard: the event a federation's store stopped attv28 hours1-2/+3
| | | | | | The federation view shows, below this node's party, the event its store stopped at (`stopped` in `GET /events`), why, and how many events it holds back, with what to do: run a continuum that reads it, or drop it. The page check renders one.
* federation: a node stops at a version it doesn't readtv28 hours6-12/+59
| | | | | | | | | | | | | | | | | | | | | | 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.
* store: a drop refuses whatever writes what a dropped event writestv30 hours1-6/+9
| | | | | | | | | | | | | A fold may say what an event writes that others may write alike (`Fold::writes`): of the federation, a version event's version. A node whose operator has it drop such an event drops the taken events writing the same with it, and refuses any writing it from then on, whoever wrote it anew: of a version, it takes no other version event naming it and writes none itself, though it holds the votes that passed it. The node keeps what each dropped event writes in its store file, across restarts; allowing one of them takes them all back. Row 51 of the federation's attacks has its test, and waits no more.
* docs: references to another document's section linked to ittv35 hours17-76/+101
| | | | | | | | 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 ittv35 hours4-5/+6
| | | | | | | | 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 backtv35 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 keys, nodes: shown given no change, --set, --forcetv35 hours4-15/+18
| | | | | | | | | | `keys` and `nodes` alone (`--list`) show the party's key set or node list as it counts at the node, one a line, without a key. `--set` writes it whole, none twice, in place of the arguments that did; `--add` and `--remove` change it as it counts. A set or list left empty, whichever way (`--set` with none, `--remove` of the last), is written with `--force` only: none of the party's writes count without keys, nor its nodes as members without a list.
* continuum-party: votes and proposals checked for the key a version namestv35 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 keys, nodes: --add and --remove, and the key they needtv35 hours2-6/+15
| | | | | | | | | | | | | `keys` and `nodes` write the party's key set or node list whole, or, with `--add` and `--remove`, the set or list as it counts at the node with those added or taken off, each of which must change it; the client says what it writes. Node IDs are checked as the federation spells them. A set or list is signed with a key the current version names for the party: the client checks that first, and where it isn't one, or the party is none of the version, says that only a version naming the party's keys or list anew changes them, which a party proposes and the parties pass.
* continuum-party propose: the proposal's hash, and --yestv35 hours2-7/+12
| | | | | `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 onetv35 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 changetv36 hours3-9/+14
| | | | | | | `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 votetv36 hours3-7/+19
| | | | | | | 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.
* continuum-party: a key the ssh-agent holds, given itselftv36 hours1-7/+10
| | | | | | | | | `--key` gives a public key itself, an `authorized_keys` line, as well as a file of them: of a file of several, the first signs, with a warning naming it, and another is given itself to sign with it. An agent that doesn't hold the key given signs nothing, and the client stops before it records or puts what it would have signed, saying which key it asked for.
* guides: which keys an ssh-agent signs a party's events withtv36 hours1-4/+10
| | | | | | | A smartcard's or a security key's PIV key, through PKCS#11, or a key in a Secure Enclave or a phone, each ecdsa-sha2-nistp256 or ssh-ed25519; a security key's FIDO key (`-t ecdsa-sk`, `-t ed25519-sk`) is no party's key.
* federation.md, guides: a change taking what was refused keeps the numbertv36 hours1-0/+7
| | | | | | | | A change that only has the federation take what it refused, reading nothing it took otherwise, as ecdsa-sha2-nistp256 keys, keeps the federation's number: it is rolled out to every node first, and used after. A node that doesn't take it refuses what uses it, a version naming such a key among them.
* guides: keys in an ssh-agentslopulus2 days3-6/+30
| | | | | | A party's key is `ssh-ed25519` or `ecdsa-sha2-nistp256`; the client signs with a private key file or through an ssh-agent holding the key, given its public key. Code of its own signing with ECDSA makes `s` low, which `ssh-keygen` does only half the time.
* dashboard: the federation, in a swarm holding a storetv2 days2-0/+10
| | | | | | | | | | | | | | 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.
* events: the store's summary names the node's party, and whether it votes for ittv2 days2-7/+8
| | | | | | `GET /events` names the party the node is of (`party`, `--store-party`) and whether it votes for it by itself (`votesByItself`, `--store-vote-key`), and so casts a vote by hand (`POST /admin/events/vote`): what a page offering votes through the node asks.
* continuum-party: options from configuration files, as the node'stv2 days1-1/+5
| | | | | | | | | `continuum-party` takes its options (`node`, `token`, `key`, `record`: `config::PARTY_OPTIONS`) on the command line and in configuration files of the node's format: `--config`, repeatable, arguments winning, `--unset`, includes and imports. The configuration's loader takes the options it reads as a table (`config::with_options`, `config::merged`, `file::load_with`), the node's or the client's, and a key naming none of them is an error in either; `node` and `token` are secrets, never logged.
* 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 days3-5/+21
| | | | | | | | `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: designing a federation's rulestv2 days2-0/+91
| | | | | | How rules match, a namespace each, zones and blocks a party holds by its name, shared places given by rules of their own and kept apart from party names, what rules cost in votes and size, and the krebs registry's rules as an example.
* guides: building on a federated swarm's APItv2 days2-0/+91
| | | | | | Reading what counts and when to read again, writing through the party's client or as events of its own spelled and signed as the federation does, when a write counts, one writer at a place, keeping a namespace in step, and the store API refusing writes.
* guides: what to watch in a federated swarmtv2 days2-0/+47
| | | | | | Beside what every node needs watching: a version a node refused, a node without its store, the proposals and the version, the members, the events beyond the checkpoint, and the store's log lines at warn and error.
* guides: upgrades and the federation's numbertv2 days2-0/+36
| | | | | | Upgrading the nodes of a federated swarm, each party its own, close together; what the federation's number names, fixed by vectors; a version of another federation refused, and moving to the next one by a version.
* guides: remakes under a federationtv2 days2-0/+64
| | | | | | Compactions only, the electorate among the store's members, the snapshot holding the store read at the base, what a node puts again after a switch, the lower of two epochs, which epochs a node rejoins, and a swarm that never remakes.
* guides: refusals and dropstv2 days2-0/+73
| | | | | | What `GET /events/refused` shows and of which kinds, the events a refused change carried, what the store file keeps across restarts, having a node drop events and take them back, and when an operator does.
* guides: a drop's answer as the node writes ittv2 days1-1/+1
|
* guides: a node voting by itselftv2 days2-0/+77
| | | | | | Setting up a node to vote for its party, its key and the party's one record, voting by hand through it, its rules for following, proposing checkpoints and voting `false` beside, what it keeps to, and what its log says.
* 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: common changes to a federation's versiontv2 days2-0/+111
| | | | | | The next version begun from the current one, and recipes as jq filters for letting a party in, taking one out, giving and taking back a place, zones and blocks, and keys named anew; what a party changes by itself; and a version that only moves the store on.
* guides: what a federation promisestv2 days2-0/+63
| | | | | Who a party and the adversary are, the three promises in plain words, what isn't promised, and what that asks of a party, an operator and an application.
* guides: forking and following in a federationtv2 days2-0/+80
| | | | | | | When a group forks, choosing the heads, the fork's version, its root as a node builds it, starting the fork's nodes and beginning a record there; what a node holding the history finds of a fork's root; and following a fork, coming back, and groups that parted coming together.