| Commit message (Collapse) | Author | Age | Files | Lines |
| |
|
|
|
|
|
|
|
|
|
| |
Getting started lets makefu in with `propose admit`, lass seeing what it
votes on before it casts, and reads with `values` and `status`; the
upgrades guide proposes a revision with `propose revision`, the
checkpoints guide a checkpoint with `propose checkpoint`, the keys guide
names keys anew with `propose keys` and writes a namespace again from
`values --json`; the troubleshooting guide points at `status` and at
forks by what they are for. The JSON and `next` stay where a version is
written by hand.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
A release is tagged v<version>, and its version says, from the
operator's side, how to upgrade to it from the release before: a patch
one node at a time, fixes only (a fix to what the federation judges
comes as a revision); a minor one node at a time still, adding to the
API or bringing a revision the parties then pass; a major one every node
close together, a flag day: no wire version both releases speak, a
document, change or snapshot built otherwise, files the node can't
restart with, the API or continuum-party changed other than by adding,
or a new federation. Before 1.0.0 any release may be a flag day, and its
tag's message says whether it is.
operations.md and the federation's upgrades guide say so; a node
speaking one wire version, every change of the format is a major
release. architecture.md said wire formats grow by appending so that a
swarm upgrades node by node, which no build does: every change bumps
the version, and builds tell each other apart instead.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
`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.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
|
| |
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.
|
|
|
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.
|