aboutsummaryrefslogtreecommitdiffstats
path: root/src
Commit message (Collapse)AuthorAgeFilesLines
* continuum-party status: IDs and hashes wholetv2 days1-14/+5
| | | | | | | | Now that `status` gives each thing a line of its own, there's no line to keep short: the store's ID, its checkpoint's and the version's hash are written whole, as node IDs and proposals' hashes were already; so are the proposals' hashes in what a vote's guard says. Keys still go by their fingerprints.
* continuum-party: a record held against the node's votes, a wait, restoretv2 days2-5/+372
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | A party votes from one record; a second record voting beside it, or one begun anew after a loss, can make the party vote twice. The client votes by its record, never by what a node shows, and still should look. Before a vote (`consistent`, `unrecorded`), the party's votes on the current version that the node shows (each proposal's yes and no) are held against the record's (Record::votes_cast): one the node shows that the record lacks refuses the vote, naming it and `restore`; one the record holds that the node doesn't show is said, as on its way or held back. Where they agree, nothing is said. What may keep a vote from the node is said too (`cut_off`, from counts' `heard`): the party's own nodes the node hasn't heard from in five minutes, through which another vote of it may have gone; and the parties none of whose nodes it heard from lately, where they are a third of those with nodes or more: a part of the swarm cut off. Then it waits (--wait SECONDS, 5 unless given, on vote and propose) and asks the node again: a vote cast elsewhere just before arrives first. A version passing meanwhile ends it, as the proposal lapsed. `restore` takes the party's votes on the current version, as the node holds them, into its record, or a new one of --party (Record::restore, checking each vote's signature, its party and version, none twice); a record begun on the current version casts on it then. Best effort: a vote on its way from elsewhere isn't among them, and what `again` signs anew, and the nays that freed an earlier `true`, it doesn't learn.
* events/counts: when this node last heard from each listed nodetv2 days1-2/+43
| | | | | | | | | Each party in GET /events/counts gives `heard` now: by node ID, how many seconds ago this node last heard from each node the party lists (its peer state's last_seen), 0 for itself, left out where it never heard from it since it started. A party's client reads from it whether nodes are cut off, where a vote may be held back, and a party's session, which reads no /peers, has it.
* continuum-party get: what counts, as JSON, a path at a timetv2 days1-0/+127
| | | | | | | | | | | | | | | What counts is kept by place, each place's value whole: `values` showed it so, a place a line, and `--json` as one object keyed by places. An application holds it as one tree. `get [PATH]` reads it so (tree, at): each place's value at its path, the maps on its way made, so that `get home/tv` is one object of everything under it, and `get home/tv/hosts/laptop/ip6` reaches into a place's value, a list's items by their index. Where a place lies under another's value, the deeper place is the later word there (merge). Nothing at a path is an error. `-r` writes a string as it is, as jq -r does; other values as JSON. Bash completes it with places and the paths on their way.
* continuum-party status: a key, a node, a party a line, nodes by their namestv2 days2-57/+128
| | | | | | | | | | | | | | | | `status` said each party's keys and nodes in one line, separated by commas, nodes by their IDs alone. Now each goes on a line of its own, indented beneath its heading (party_lines): the keys the version names, which sign votes, proposals, the key set and node list; those of the key set as it counts, which sign writes, or `the same`; `--key`'s marked, and said where it is none of them; and the nodes, each with the name it gave itself (`--alias`) where it did, as the dashboard names nodes. The store and the version are a heading each too, the parties one a line. The names come from GET /events/counts, which gives each party's `names` now (by node ID, of the nodes that gave themselves one), so that a party's session, which reads no /peers, has them. Bash completion reads the parties from the new layout.
* continuum-party --party: the party it reads as, without a recordtv2 days2-23/+100
| | | | | | | | | | | | | A record is what votes go by, and what `again` signs anew from; for logging in as the party, and for `status`, it only named the party. So someone who only reads needed a record, begun with `init`, which should never vote beside the party's own. `--party NAME` (an option as node, key and record are, so party.toml holds it too) names the party where no record does (working_as): `init` the one it begins a record of, else the record's, else --party; --party naming another than these is an error. Commands that sign still take a record.
* continuum-party: logs in as its party by its key, with no user of the nodetv2 days1-10/+74
| | | | | | | | | | Where --node names no user and no --token is given, the client logs in to the node as its party (Node::log_in): a challenge, signed with --key (a file's, or through the ssh-agent) for continuum-login, for POST /auth/login/party, whose token goes with every request then. The party is the one its record names, or, for `init`, the one it begins a record of. A party's people need a node's address and a key of their party's, nothing of its operator's.
* federated nodes: a party's keys log in as the party, for federation worktv2 days7-98/+362
| | | | | | | | | | | | | | | | | | | | | | | | A party's people work with the federation by signing as the party, with a key of its set; what they need of a node is to read and to put events, which a node's users, its operators, may do with every power besides. POST /auth/login/party takes a challenge (POST /auth/challenge) signed with one of the keys that sign for the party (fold::State::signing_keys: those its current version names, and its key set as it counts), for the namespace continuum-login, armored or as the federation spells a signature (keys::signer, keys::verifies_in: the federation's checks, but for the namespace), and answers a token as the party. Logins by key are counted per party as per user (challenge::take_with, shared with logging in by a registry's keys). The token names the key (Claims::party). Such a session does federation work alone (api::access::federated): what --store-readers do, and POST /events; anything else is 403. Every request checks that the key still signs for the party: once a version or the party's key set drops it, 401. A build from before reads no token naming a key, as its claims deny fields they don't know, so never takes a party's session for a user's; and only the node that issued it takes it, as every token in a federated swarm.
* federated nodes: users who read the federation alone (--store-readers)tv2 days6-0/+104
| | | | | | | | | | | | | | On a federated node, every user its htpasswd or proxy lets in may do everything: put events, have it drop what it took, vote through it with its party's key, make fork roots, read the document. An application or someone watching needn't act for the node. `--store-readers USER,...` names users who read the federation and do nothing else (`api::access::federated`, before the registry's checks): GET and HEAD of the events API (/events and below), checking a fork (POST /events/fork), and keeping a session (whoami, refresh, logout); anything else is 403, saying so. Its other users are its operators, as all were: a node setting nothing changes nothing.
* party: the change test without the rule the harness gives alreadytv2 days1-5/+2
| | | | | Spec::first begins every first version with home/{party}/**; the test gave it again, so the version had four rules, not the three it counted.
* continuum-party keys: files of keys tootv2 days1-19/+17
| | | | | | | | `keys --add`, `--remove` and `--set` took authorized_keys lines alone, each one argument, so a .pub file went in as "$(cat phone.pub)". They take files of such lines too now, as `propose admit` and `propose keys` do (keys_given, of which key_lines is the one asking for a key at least), and bash completes files there.
* continuum-party found: a federation's first version from its partiestv2 days1-13/+216
| | | | | | | | | | | | The founders wrote the first version as JSON by hand. `found PARTY=KEY|FILE...` writes it: each party with its keys, an authorized_keys line or a file of them, again for more, since 0; --nodes PARTY=NODE,... their node lists, empty where not given; --rule PATH=WRITER the rules in order, `nobody` for false, and without any, each party writing under home/{party}/; --revision FEATURE a later revision. It is checked as a first version (Version::read, changes_validly), and goes to standard output, for `root` to make the root of. The feature lookup is shared with `next` (adding).
* continuum node-id: a node key's ID, without starting the nodetv2 days2-2/+54
| | | | | | | | | The founders name each node by its ID in the first version, before the federation starts; getting it meant starting a node once with --node-key-create and reading its log. `continuum node-id FILE` prints the node ID of the key FILE holds and exits, `--create` making the key there first where there is none (saying so on standard error). Logs are off for it, as for --print-config: the ID goes to standard output alone.
* continuum-party: status and valuestv2 days1-29/+268
| | | | | | | | | | | | | | | | | `status` says at a glance where the party and its node stand, from the node's /events, /events/counts and /events/refused and the party's record where there is one: the store, its checkpoint and heads; the current version, its federation, revision and parties, and how many pass a change; the party's keys (by fingerprint) and nodes as they count, and whether the version names --key; the node's party, whether it votes by itself, and its stop; each proposal on the current version as `show` begins (ballot_line, shared with it); the versions the node refused of its own; and how many of the party's events a move refused, which `again` signs again. `values [PATH]` shows the values that count, all or under a place, each with who writes there by the current version's rules; --json as one object, by place.
* continuum-party: forks by what they are for, by a proposal, at the node's headstv2 days1-18/+223
| | | | | | | | | | | | | | | `fork` took a version written by hand and every head by name. Now: * fork FILE [HEAD...]: the heads the node shows where none are named; * fork proposal PROPOSAL: by the version of a proposal on the current version, as a fork's version is usually one that didn't pass; * fork admit, remove, give, take, keys, nodes, revision: by the next version changed as they say, as propose does (not checkpoint: a fork is at heads of its own); each subcommand taking --at HEAD... and --founder PARTY=NODE,..., which names a party's node list anew in the fork's version, so that the nodes its founders run it on are members there.
* continuum-party: propose admit, remove, give, take, keys, nodes, checkpoint, ↵tv2 days1-34/+519
| | | | | | | | | | | | | | | | | | | | | | | | | | | revision The changes made most no longer go through `next`, jq and a file: each is a subcommand of `propose`, which writes the next version changed so (Intent, intended) and proposes it. * admit PARTY --keys KEY|FILE... [--nodes NODE...]: its keys and node list named anew since the new number; a party already, or no party's name, refused. * remove PARTY: its keys, node list and the rules giving it places go. * give PATH PARTY|{party}: a rule first; one of that path before goes. * take PATH: the rule of that path goes, and where another rule may still give one of its places (overlaps), a rule giving them to nobody goes first. * keys PARTY KEY|FILE..., nodes PARTY NODE...: named anew. * checkpoint: at the heads the node shows. * revision FEATURE: as `next --revision`. Keys are authorized_keys lines, or files of them. Every proposal, a file's too, now says what its version does first (version_lines, shared with `show`) and asks on a terminal; with --yes the one question covers the vote, which then says and asks nothing more. A version changing only its number isn't proposed. --print writes the version instead, to change by hand and propose as a file.
* transport: wire versions spoken side by sidetv2 days10-75/+430
| | | | | | | | | | | | | | | | | | | | | | | | | | | A build speaks wire versions OLDEST to VERSION and writes each node the newest both speak (wire::choose), as the node's SPEAKS says; the oldest until it says. The identity layer keeps that per address (Book::speaks): a SPEAKS from an address sets it for the address, and for every address of the node proven there, and a new address of a node takes it over. Paths encodes each message for an address in its version (Transport::encode_in; Transport::encode is the newest). So that two nodes know what the other speaks once they have proven themselves to each other, before any other message goes between them, a SPEAKS goes ahead of every WHO and ME, and WHO and ME are read in every version from 52 on (wire::PROOFS): their tags and layout never change. Without that, a node whose oldest version is past the other's couldn't read its proofs, and the two would never get to the handshake that says what each speaks. A SPEAKS naming no version this build speaks is logged as a message of another version is, naming the node to upgrade, the versions as ranges. A 0.0.1 node takes a SPEAKS from an address not yet proven for any other message from there: it drops it, and asks WHO. This build speaks 52 alone, so nothing it sends changes but the SPEAKS ahead of the proofs. A release adding a version encodes and decodes the older ones from their own, frozen, types.
* continuum-party: show, a proposal in words before a votetv2 days2-56/+422
| | | | | | | | | | | | | | | | | | | | | | | | | | A party saw a proposal as its version's JSON changed field by field (`keys.makefu: - -> {"keys":[…],"since":4}`), and voted with nothing more before it. `continuum-party show PROPOSAL` now says what a party votes on, in words (`client::described`): * whether it passed or is dead, who voted what, and how many more `true` pass it; * who proposed it, and the version's number; * the parties it lets in or takes out, with their keys by fingerprint, as `ssh-keygen -l` gives them, and their nodes; the keys and node lists it names anew, with what it adds and drops; * the rules it adds and drops, each where it is among the rules, a rule moved being dropped at one place and added at another; * the checkpoint it moves the store to, and what moving there refuses of what the node took (`beside`); the revision it moves to, and the nodes not known to know it; * the places holding a value whose writer it changes, and why no client backs it, where none does. `proposals` says each proposal so. `vote`, through the node too, says it before anything is cast, then its warnings, and on a terminal asks: `y` casts, anything else casts nothing. Without a terminal, as in a script, it asks nothing.
* events: what moving to a proposed checkpoint refuses, showntv2 days2-17/+70
| | | | | | | | | | | | | | federation.md, and row 68, said a node shows, for a proposed checkpoint, what it holds that its heads lack; no node did. `GET /events/counts` now shows, of each proposal whose version names a checkpoint, the writes, key sets and node lists the node took that moving there refuses (`beside`; null for another version): neither among its heads, in their history, nor above them, as the move has it, which their parties sign again. Proposals and votes lapse with the move, and merge events count for nothing: they are left out. `Store::beside` finds them in one pass, as the move itself does: the two share `Store::above`, which the move computed inline.
* continuum-party: a directory for each federation, the only one used unaskedtv2 days2-7/+187
| | | | | | | | | | | | | | | | | | | A party named its node, key and record on every command, or a file of them with --config; one voting in several federations kept files apart by hand. Without --config, the client now reads a federation's own directory, `continuum/federations/NAME` in $XDG_CONFIG_HOME or ~/.config: its `party.toml` of the client's options, its record (`record`) and, where there, its key (`key`); options on the command line, or `record` and `key` in `party.toml`, win. `--federation NAME` chooses one; where there is only one, it is used without being named; where there are several, the client says which there are and asks for one. `root`, `judge` and `twice`, using no options, read none. `init --federation NAME` begins a federation's directory, only its owner reading it, its `party.toml` holding the options given on the command line with it (`node`, `token`, `key`, the key's path made absolute; the node's default left out), and the record in it.
* continuum-party: hashes named by their prefixes, the shortest markedtv2 days2-7/+144
| | | | | | | | | | | | | | | The guides wrote `vote 8d02… yes`, and the client took a whole hash only. It takes a proposal's hash by a prefix of four digits or more that no other proposal on the current version starts with (`client::named`), and says which proposals a prefix names where it names several; a whole hash is itself, as before. Heads given to `fork` are named so too, among the heads the node shows. Four digits at least, so that a prefix read a moment ago doesn't come to name a proposal made since, as one or two soon would. Where it shows a proposal's hash (`proposals`, `propose`), the client marks the shortest prefix that names it, in bold, on a terminal unless NO_COLOR is set; elsewhere the hash is printed as it was.
* wire: a peer on another version is named older or newer, with what to upgradetv2 days1-5/+42
| | | | | | | | | | | A node meeting messages of a wire version it doesn't speak logged `Peer speaks another wire version (another build)`, with the versions as fields only. It says now, in the message, which build is the newer and which node to upgrade: this one, where the peer's is newer (`upgrade this node to talk with it`), else the peer's (`upgrade that node`), with the peer's version and the ones this build speaks. Its fields are the peer's version and the oldest and newest this build speaks.
* vote: a second `true` builds on the nays that freed its partytv2 days3-11/+107
| | | | | | | | | | | | | | | | | | | | | | | The federation takes a party's `true` only where, at its history, every other proposal it backed on that version is dead. A party's client, and a node voting by itself, built a vote on the events proposing what it votes on alone. A proposal made while the party's first `true` was alive, at a history holding it, holds that `true` in its history, and not the nays that ended the first proposal later: the party's `true` on it was refused, though its record cast it. The compromise case: five back X, Y is proposed, X dies, its backers back Y. A vote now builds on one event proposing what it votes on, and on the nays that freed its party (`client::building`), so the first proposal is dead at its history too. One event proposing it is enough, so many proposing it again don't push a vote past the dependencies an event may name. A checkpoint's vote builds on its proposal alone: one of those nays in the history of its heads, named, would put the vote beside them. A party freed only after the heads were named backs that checkpoint not, and its client says so before casting; it backs one proposed after. Row 74 is tested (`federation_attack_74`); federation.md and the guides say so.
* config: store-propose-versions is 1 unless set, in the settings tootv2 days2-2/+8
| | | | | | | | The option's help said 1 unless set, but the setting itself stayed unset, so a node proposed no checkpoint after a version unless told, and `options_and_settings_agree` failed: `default of store-propose-versions`, 1 against null. The setting is a count now, 1 unless set, and 0 has the node propose none after versions.
* continuum-party: which places a proposal gives another writertv2 days4-3/+87
| | | | | | | | | | | | | | | Rules go by first match, and `{party}` matches only the names of the version's parties: admitting a party named as a segment of a place, or changing the rules or their order, moves who writes the places below it, and what their writer wrote there counts no more once the version passes. Nothing said so: a proposal showed only its fields' changes. `client::writers` names, of the places holding a value, those whose writer a version changes, as `place: before -> after` (`nobody` where no rule gives it one). `continuum-party proposals` prints them under each proposal's changes (`who writes …`), and a fork's check does for the fork's version (`writers` in POST /events/fork). The guides and federation.md say so; row 72 is tested (`federation_attack_72`).
* fork: a fork's check says what its version changes, rules among ittv2 days3-8/+37
| | | | | | | | | | | | | | | A node holding the history up to a fork's heads said whether it builds the root, what it holds that those heads lack, and which parties' keys the fork's version gives otherwise. A founder could change the rules, or only their order, which says who writes where, and nobody joining was shown it. The check now says what the fork's version changes of the version current at those heads, a line each as a proposal's are shown (`client::changes`): `changes` in POST /events/fork, and `continuum-party check` prints them. federation.md and the forking guide say so, and that a fork's ID is compared whole: a founder trying versions can steer its first few digits.
* vote: a checkpoint after every version that changes more, unless told otherwisetv2 days2-7/+3
| | | | | | | | | | | | | | | After a close vote, one key voting twice passes a rival version at a history from before the version that followed, the votes cast before counting with its own, any time until a checkpoint above that version: nodes that took the version refuse it, but one lagging behind, or joining from the root, may take it. A node voting by itself proposed a checkpoint after a version only where its operator set `--store-propose-versions`; now it does unless told otherwise (1 unless set; 0 never so). Versions that change more than moving to a checkpoint are rare, so the cost is a checkpoint each. A default set, store-propose-versions no longer asks for store-vote-key, as store-held-for and store-back-after don't.
* vote: the version that moved the store counts not toward the next checkpointtv2 days3-6/+28
| | | | | | | | | | | | | `--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.
* peers: what each peer said it speaks and knows, in GET /peerstv2 days3-27/+69
| | | | | | | | | | | | | | | | GET /peers shows, of each peer, what it said with its handshakes (SPEAKS): its `knows`, the wire versions it speaks, the oldest and the newest, and the newest revision of the federation it knows; null where it said nothing, a build from before SPEAKS or no handshake from it since the node started. `localKnows` is the node's own. So every swarm, federated or not, shows which builds its nodes run, as far as each heard. `swarm::speaking::shown` shapes it, for GET /events/counts too, whose `knows` is the same; docs/openapi.yaml has it once, as `Knows`. Without the federation feature, a revision reads as one this continuum doesn't know. `Speaking::of` is now used in every build, not only federated ones, which warned of it as dead code.
* release: --version says what decides which builds work togethertv2 days5-0/+75
| | | | | | | | | | | | | | | | `continuum --version` and `continuum-party --version` say, after the release, the wire versions the build speaks, the federation and the revisions of it it knows (with the `federation` feature), and the Automerge version it makes documents with: continuum 1.0.0 wire versions 52 to 52 federation 1: the base revision, revision 1 (merge-events) automerge 0.12.0 `-V` says the release alone, as before; continuum-party had no version at all. The Automerge version is the one the crate itself reports (`document::engine_version`), so it follows Cargo.lock.
* federation: which nodes know a revision, in counts and before a `true`tv3 days4-10/+170
| | | | | | | | | | | | | | | | | | `GET /events/counts` says, of each node a party lists, what it said it speaks and knows (`knows`, by node ID): the wire versions, the oldest and the newest, and the newest revision of the federation it knows, by number and ID and as people read it, its number null where this continuum doesn't know it; null where it said nothing, a build from before SPEAKS or one the node didn't hear from; the node's own as it is. So the nodes still to upgrade before a revision passes show, every party's, where before a party's operators could check only their own. A party's client, backing a proposal that moves to another revision, warns of every node of any party not known to know it, a line a party naming each and what it said: once it passes, those stop at it till upgraded. `next` warns alike, of the revision it moves to, or of the later one it suggests. A warning, not a refusal: what a node heard is no proof, and a node not heard from may well be upgraded.
* transport: SPEAKS, which wire versions a node speaks and what it knowstv3 days9-5/+160
| | | | | | | | | | | | | | | | | | | | | | | Before each HELLO and each HELLO_REPLY, a node sends SPEAKS: the oldest and the newest wire version it speaks, and the ID of the newest revision of the federation it knows. It stands outside the wire versions, its first byte 0, which no version is, laid out as no build changes: that byte, the oldest, the newest, then 32 bytes of the revision's ID where there is one; a reader takes those and leaves whatever follows, which a later build may add. So a peer on another build reads it too, and nodes on different builds can say what they run, which a rollout needs. A build from before it takes it for a message of another wire version and logs that once of the peer (version=0), reading the rest of the peer's messages as before: SPEAKS rolls out node by node, with no change of VERSION. The node keeps what each peer said last (`swarm::speaking`, at most 4096 peers). It counts as `hello` traffic. `OLDEST`, the oldest version this build reads, is `VERSION` for now: a range for a later build to widen. operations.md also says what is so of the other-version warning now: every transport logs it once per peer at warn, not Mycelium alone.
* federation: checked against the release a federation-<F>.<R> tag namesfederation-1.1tv3 days3-317/+60
| | | | | | | | | | | | | | | | | | | A corpus of generated histories, committed, said what this code made of them, right or not, and held hundreds of kilobytes a revision; generated from code that changes, it could only be checked, never written again. Each release that makes a revision is tagged `federation-<F>.<R>`, the federation's number and the revision's (`federation-1.1`, revision 1 of federation 1). `scripts/federation-check` writes histories from this tree (`write_histories`, an ignored test): of each revision it knows and each kind the properties generate, those of a few seeds from a random one it says, and the attack tests' crafted ones, as each test offered them where nothing but offers made them. It judges them with `continuum-party judge` here and with the continuum the latest such tag names (or one given), built in a worktree and kept between runs, leaves out those whose root the tagged one reads as none, and says where the two differ. Run before a release, not by `cargo quick`. The corpus and its test are gone; the test plan and `federation.md` say how a release is checked.
* attacks: the histories they offer, recorded while asked totv3 days1-20/+159
| | | | | | | | | | | The attack rows' tests craft histories and assert what the design says becomes of each event: worth judging by later releases too, as they were judged when the tests passed. Their stores are made and offered through the harness (`Fed::new`, `Fed::offer`), and while `recording` runs a test, each of them is recorded: its root, the events offered in order, and whether nothing but offers made it what it became (an operator's drop doesn't). A test that fails records nothing. `TESTS` names every attack test, which a test checks against the file.
* federation: continuum-party judge, a store's verdicts in a format releases keeptv3 days3-0/+205
| | | | | | | | | | | | | | To check that a release judges histories as an earlier one did, under every revision that one knows, each must say what its store makes of the same histories, in the same words. `continuum-party judge` reads histories from its input, each `case <label>`, `root <hex>` and `event <hex>` for each event in the order offered, and prints for each what became of every event by kind (`became <ID> <kind>`, never a refusal's words) and what the store reads after (`reads <JSON>`): its checkpoint, the current version, the values at places, the members, and the event it stopped at; `root none` where the root reads as none, as one of a revision this continuum doesn't know (`federation::judge`). The format is never to change: an earlier release prints it too.
* properties: votes mostly on the earliest proposal, a stop sought past the casestv3 days1-39/+85
| | | | | | | | | | | | | `the_store_judges_and_reads_as_the_model` asks that some history stop a store, where two thirds pass a version this continuum doesn't read. Merge events in the generator shifted every seeded history, and of the 64 cases with such versions none stopped; the corpus's scan found stopping seeds only past them (279, 314, 330 and others). Of the proposals a party knows, it now votes on, and writes the version event of, the earliest on the version current where it writes more often than not, so that parties vote alike and versions pass. And where none of the cases stopped a store, the test scans later seeds of those kinds till one does, up to 1000, and checks it too: a stop is checked whatever the generator's luck.
* corpus: cases chosen by what they show, merges by nodes their party liststv3 days2-16/+102
| | | | | | | | | | | | | | The corpora written from four seeds of each kind showed little: of 32 histories, 4 versions written, no move and no stop, and every merge event refused, as the generator signed them with any of ten node keys, so the corpus of revision 1 judged as the base revision's did. A generated merge event is signed by a node its party lists there, more often than not. Of each kind, the corpus keeps the histories of the first two seeds, and of the next 400 those showing what the ones kept don't (`shows`: of each kind of event, what became of one; a version written, a move, a stop), eight at most. The check asks that together a revision's cases show a version written, a move to a checkpoint, a stop, and a merge event taken where the revision has merge events, else refused.
* federation: a corpus per revision, judged alike by every later continuumtv3 days3-12/+261
| | | | | | | | | | | | | | | | Nothing checked that judging under a revision stays what it was: a change to the fold that alters what an earlier revision takes, refuses or reads parts nodes running it from nodes that don't, and the tests regenerate their expectations with the code. For each revision this continuum knows, a file in `src/federation/corpus/` holds histories generated at that revision, of every kind the properties generate, each event's bytes with what became of it, by kind and never by a refusal's words, and what the store reads after; its first line names the revision by its ID. It is written once, as the revision is made (`write_the_corpus`, an ignored test run by hand), and never edited after; every later continuum judges it alike (`every_revision_judges_as_its_corpus_says`), which fails where a revision has no corpus yet, saying how to write it. The test plan describes it.
* federation: revisions shown, named, and moved to by handtv3 days4-12/+179
| | | | | | | | | | | | | | | | | 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 holdstv3 days2-27/+30
| | | | | | | | | | | | | | | | 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 nametv3 days2-4/+137
| | | | | | | | | | | | | | | 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 revisiontv3 days11-30/+217
| | | | | | | | | | | | | | | | | | 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 followstv3 days3-4/+193
| | | | | | | | | | | | | | | | | | 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.
* continuum-party: warns before a true that only every nay left endstv3 days2-0/+79
| | | | | | | | 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 versionstv3 days4-9/+63
| | | | | | | | | | | | | | 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 whiletv3 days2-12/+89
| | | | | | | | | | | | | | | 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 movetv3 days3-34/+157
| | | | | | | | | | | | | | | | | | | 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 partiestv3 days3-5/+56
| | | | | | | | | | | 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`).
* store: a new event builds on as many heads as an event may nametv3 days6-5/+40
| | | | | | | | | | | A party's client builds on the heads its node shows (`GET /events`), and a node on its own heads; an event names at most 64 dependencies. With more heads than that, where many write at once and nothing merges, every event built on them was none. `Store::building_on` gives the heads, as many as an event may name (`Fold::DEPENDENCIES`, the federation's 64), the earliest taken first, so that what is written merges what stayed apart the longest; `GET /events` shows those, and a node voting by itself builds on them.
* federation: votes on the events proposing a checkpoint above its headstv3 days5-19/+159
| | | | | | | | | | | | | | | 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`).