aboutsummaryrefslogtreecommitdiffstats
Commit message (Collapse)AuthorAgeFilesLines
* continuum-party: options from configuration files, as the node'stv18 hours5-70/+216
| | | | | | | | | `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 changestv18 hours3-0/+136
| | | | | | | | `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 deadtv18 hours6-23/+120
| | | | | | | | `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 rulestv20 hours2-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 APItv20 hours2-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 swarmtv20 hours2-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 numbertv20 hours2-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 federationtv20 hours2-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 dropstv20 hours2-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 ittv20 hours1-1/+1
|
* guides: a node voting by itselftv20 hours2-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 checkpointtv20 hours1-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 versiontv20 hours2-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 promisestv20 hours2-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 federationtv21 hours2-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.
* guides: when things go wrong in a federationtv21 hours2-0/+83
| | | | | | | A version a node refused by what it took before, finding from the parties' records who voted twice, having a node drop one side's version and take the other's, answering by a fork, and what keeps a node from holding its store, syncing, taking an event, or starting.
* guides: checkpoints in a federationtv21 hours2-0/+80
| | | | | | | What a move to a checkpoint keeps and loses, a version only moving the store on and the heads to name, a node proposing checkpoints by its operator's rules, backing only heads that leave out nothing held for a while (which a node voting by itself checks and a party's client doesn't), signing again after a move, and nodes that weren't there.
* guides: a federated party's keystv21 hours2-0/+87
| | | | | | The keys a version names, kept apart with the party's record, and those of its key set, signing its writes; changing a set and signing again what should stay; changing the keys a version names; a stolen key of either kind; and the node key, which is no party's.
* guides: proposing and voting in a federationtv21 hours2-0/+118
| | | | | | | 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.
* guides: writing and reading in a federationtv21 hours2-0/+114
| | | | | | Places and the rules naming their writers, a write through the party's client and what it may hold, what counts and what stops counting, the refusals a node names, signing again what a move refused, and what `GET /events/counts` shows.
* guides: running a node of a federationtv21 hours2-0/+111
| | | | | | | What a node of a federated swarm does otherwise than any: its store options and file, members syncing with members only, its API letting in whoever its operator lets in to do everything, the store API refusing writes, joining by ID and from a pinned checkpoint, and what it writes by itself.
* guides: getting started with a federationtv21 hours3-3/+201
| | | | | | | `docs/guides/federation/` holds the guides to a federated swarm, the design saying what the rules are and they how to live by them. The first: two parties start a federation, a node each, write, read, and let a third party in by their votes. The README points to them.
* continuum-party keys: a key set from authorized_keys lines, comments left outtv21 hours1-3/+11
| | | | | | The federation spells a key without a comment, so a key set holding a line's comment is none. `continuum-party keys` takes each key as an `authorized_keys` line, one argument each, and writes it as the federation spells it.
* client: a record begun from the store's root casts on its first versiontv21 hours2-9/+42
| | | | | | | | | | A record casts nothing on the version current when it began, as a `true` sent before may be held back somewhere. A federation's first version is current from its start, so a record begun at a node casts nothing on it, and with every party's begun so, no proposal on it can pass. `continuum-party init PARTY --root FILE` begins a record from the file the store's swarm starts from, for a party that never voted in it (`Record::before`): nothing was sent before it, and it casts on every version, the first too. A node voting by itself takes such a record as its `--store-vote-record`.
* federation.md, federation-tests.md: the stages end with remakesfederation-2-stage-5tv21 hours2-4/+1
| | | | | | What a federation is used for is read and written through a node's API: kartei's entries are signed in by their parties and read from what counts there, with no stage of their own.
* federation.md: kartei's files, identifiers and rules on a federated swarmtv21 hours1-11/+25
| | | | | | | | | The registry holds each kartei namespace in its party's, a place per file. What kartei's consumers read as one for all (host and user names, the names hosts go by, addresses and blocks in every net but `internet`) is shared, at places of its own, given by krebs's rules: a party's by its name, and what kartei gives it beyond them by a rule each in the first version. What kartei's consumers read is written out from what counts, but for what names an identifier the current version doesn't give its party.
* held: the store's worker reads a document only while it is writabletv22 hours1-8/+8
| | | | | | | | | | | A rejoin makes the node's document writable again only as it ends, in the lock of the swap, once the node checked the epoch (`Holding::follows`) and follows it or gives it up. The store's worker reads nothing, and writes nothing, while the document isn't writable, checked in the lock it reads under. Whether a rejoin runs isn't enough: its state is taken up for its last checks, while the epoch's document is still the node's, and a store started from that document would keep the checkpoint it read there, and put again what it took into the document the node goes back to.
* simtest: row 15 with joiners handed an epoch they can't checktv22 hours1-40/+57
| | | | | | | | | | A node with an empty document can't tell an epoch made up from another it can't check: either way it takes the snapshot's checkpoint only where its operator named or pinned it. The others move to a checkpoint and compact; f, joining and pinning nothing, doesn't take their epoch, and g, pinning the checkpoint, takes it and reads what they read. A made-up epoch served by d, an honest node besides, is row 31's alone: d follows the others' epoch wherever it reaches them.
* simtest: d, serving a higher made-up epoch, is apart from the otherstv23 hours1-2/+9
| | | | | | Reaching the others, d rejoins their epoch, the lower, as any node holding a store does, and e, reaching only d, finds their epoch there, not d's. Cut off from them, d stays on the one it made up.
* simtest: row 15's made-up epoch is of a higher ID than the others'tv23 hours1-9/+13
| | | | | | | Of a lower one, the others try to rejoin it every so often, as in row 31, and f, rejoining their epoch, finds them away mid-sync and gives up for that, not for its checkpoint. Of a higher ID, they leave it alone; e, reaching only d, still takes it, as one joining takes the newer generation.
* remake: a failed simulation's dump shows each node's catch-uptv23 hours1-5/+15
| | | | | Its target, attempts, whether the node rejoins now, and why the last try failed, before the lines of the remake records.
* simtest: in row 15, the joiner reads as the node serving it doestv23 hours1-6/+9
| | | | | | d, serving the epoch it made up, puts again there what its store holds, as every node holding a store does: e, judging every event, reads what d reads, the checkpoint the others moved to among it, not the root alone.
* simtest: row 31's later write builds on what is above the checkpointtv23 hours1-2/+2
| | | | | It builds on tv's write, the checkpoint's head: one built on the root isn't above the heads of the checkpoint the nodes moved to, and they refuse it.
* held: nothing of a rejoin's document is read before the node follows ittv23 hours1-0/+6
| | | | | | | | | While a node rejoins, its document is that of the epoch it tries, which it follows only once it checks it (`Holding::follows`). The store's worker reads nothing of it, and writes nothing, while the node rejoins: else the store, starting there from the snapshot's checkpoint, would take one the node neither builds nor has pinned, and keep it should the node give up the rejoin.
* docs: the federation's test plan, built to stage 5tv29 hours1-5/+5
|
* simtest: made-up epochs handed to a node holding a store (rows 15, 31)tv29 hours2-1/+177
| | | | | | | | | | d serves an epoch of the next generation it made up, of a lower ID than the others', its snapshot holding the root as the document stood before the checkpoint they moved to. A node joining with nothing that reaches only d takes it, the root being what its operator named, and reads only what it holds (15); one reaching only the others takes not their epoch, whose checkpoint it neither builds nor has pinned (15); the others try d's, find its root before their document's checkpoint, and stay on theirs (31).
* remake: a test helper serving an epoch a node made uptv29 hours1-0/+15
| | | | | `testing::serve` switches a node to an epoch whose document is a snapshot it built itself, as a node serving a made-up epoch would.
* held: a checkpoint a node can't build, handed by peers, only pinned (row 22)tv29 hours1-1/+35
|
* simtest: the remake rows of a swarm holding a storetv29 hours2-6/+397
| | | | | | | | | | | | | Simulations of the store's attack rows on remakes (`docs/store.md`, Attacks): a snapshot other than its base's isn't followed (11); one coordinator's two decisions for an epoch, shown to different nodes, end on the lower epoch (13); a node away while the others switch rejoins and puts again what it wrote meanwhile (16); after a compaction whose snapshot holds a checkpoint, a node away all along follows only once its operator pins it (24); a compaction whose base comes before a checkpoint, switched after nodes moved to it, leaves them there, and a node starting with nothing reads the new document to it (28); a member deciding many compactions at once moves every node to the lowest epoch, losing no event (30).
* remake: test helpers proposing and committing against the protocoltv29 hours1-0/+66
| | | | | | | | For simulations of a coordinator that doesn't keep to the protocol: `testing::propose_again` proposes a remake's proposal again under a new ID, whatever is open, and `testing::commit_as` commits a remake at the node's heads now, whatever the votes and another decision, to a given epoch or to the epoch of the snapshot the node builds there.
* remake: holding a store, a node rejoins a lower epoch a peer servestv29 hours1-29/+17
| | | | | | | | Of two epochs decided for one, a node holding a store follows the lower ID, and a node on the other rejoins it, however many peers are on each (`docs/store.md`, Remakes): one peer on it is enough, so that two sides of unequal size come together. A made-up epoch keeps a node apart at worst, and makes it take nothing it wouldn't (`Holding::follows`).
* simtest: events written beyond a compaction's base go again (row 12)tv30 hours2-1/+93
| | | | | | A swarm holding a store compacts: events written beyond the base, on nodes that switch later, are put again in the new epoch, and every node holds every event, reads the same, and refused no change.
* remake: holding a store, a node follows an epoch only from a checkpoint it ↵tv30 hours4-0/+149
| | | | | | | | | | | | | builds A node of a swarm holding a store rejoining an epoch (`docs/store.md`, Remakes) follows it only where its snapshot has the swarm's policy and store, and holds the node's document's checkpoint, one it builds from that document, or one its operator pinned; with an empty document, the root of its store too (`Holding::follows`). A made-up epoch holding another, the root after the store moved on, say, would leave it holding events whose history nobody puts again: it stays on its own, as when a rejoin's check fails, and tries again later.
* remake: holding a store, of two epochs decided for one, the lower IDtv30 hours2-3/+108
| | | | | | | | | | In a swarm holding a store, of two epochs decided for one, by a coordinator that wrote two decisions or by remakes decided at once, a node follows the one with the lower ID, and a node on the other rejoins it, however many peers are on each (`docs/store.md`, Remakes): a node switches to the lower of two committed remakes of its epoch, follows the lowest of several newer epochs, and a ready node rejoins a lower one of its own generation that enough peers serve.
* remake: holding a store, a node puts again what the document it left holdstv30 hours4-36/+157
| | | | | | | | | | After a switch or a rejoin, a node of a swarm holding a store puts again what the document it left holds that a store starting at the new document's checkpoint takes, by its own refusals and drops, and the new one lacks (`docs/store.md`, Remakes, `Holding::left`): what it held beyond the base, and, where it moved to a later checkpoint since, what a store starting at the snapshot's takes to reach it. Its events aren't replayed into the new document, so none nobody takes go along.
* vectors: the snapshot after a checkpoint, as a run printed ittv30 hours1-1/+4
|
* holding: the tests' other nodes write under writers of their owntv30 hours1-1/+18
| | | | | | | | A writer's changes are its first change's author's, so a node writing in a test after another under the same writer wrote as that one: a decision by another than the coordinator was taken as the coordinator's. Another node now writes under a fresh writer. The proposal written again differs, as one written the same makes no change.
* vectors: a snapshot after a checkpointtv31 hours1-0/+75
| | | | | | | The snapshot of a compaction after the store moved to a checkpoint, built from a document every run builds alike: its change's hash and bytes, which a run of this code prints, as no script apart encodes Automerge. Left empty until a run prints them.
* events: the tests put events at time 0tv31 hours1-5/+7
| | | | | The same events put by the same writer make the same change, so that a document built of them in a test is the same bytes on every run.
* remake: a holding swarm's electorate is the fold's memberstv31 hours1-1/+13
| | | | | | | The entry of a node that isn't a member counts for nothing where continuum reads entries (`docs/store.md`, Members): a remake proposed in a swarm holding a store counts, of the members alive recently enough, those the fold names with the party their entries name.