| Commit message (Collapse) | Author | Age | Files | Lines |
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
What the docs left unsaid:
* A checkpoint names every event that counts, 32 bytes each, and has no
size limit, unlike an event; nothing bounds what a party writes where
its rules let it, so every node, snapshot and fork's root holds as
much as it writes. A party writing more than the others will hold is
taken out by a version, or the others fork. Row 73 says so, and the
rules guide.
* Before the first checkpoint passed, a node joins from the root and
nobody pins anything: a chain of old keys needs keys a version
replaced, and a node voting by itself proposes a checkpoint after
every version that changes more; until that passes, a joining node
takes the first of two versions it judges, as row 63 has it.
* A `true` binds; what binds nobody is said outside the votes. The
voting guide shows how parties count their support first by plain
writes, at a place a rule gives each (`intents/{party}/**`), read at
`values` in GET /events/counts.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
| |
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.
|
| |
|
|
|
|
| |
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.
|
| |
|
|
|
|
| |
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.
|
| |
|
|
|
|
| |
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.
|
| |
|
|
|
|
| |
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.
|
| |
|
|
|
|
| |
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.
|
| |
|
|
|
|
| |
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.
|
| |
|
|
|
|
| |
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.
|
| |
|
|
|
| |
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.
|
| |
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
| |
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.
|
|
|
`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.
|