| Commit message (Collapse) | Author | Age | Files | Lines |
| |
|
|
|
|
|
|
|
|
|
|
| |
`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::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.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
|
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
|
|
|
| |
`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.
|
| |
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
|
|
|
|
|
|
| |
`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.
|
| |
|
|
|
| |
`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.
|
| |
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
| |
`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.
|
| |
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
|
|
| |
`--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.
|
| |
|
|
|
|
| |
The test fails without OpenSSH on the machine testing, rather than
passing without asking anything. Its directory is a scratch directory,
removed when the test ends, the agent stopped before it.
|
| |
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
| |
Row 62 names an ECDSA signature's twins, `s` high (the order less `s`)
and `r` or `s` with zeros more in front, each none. Its test offers the
ECDSA vector's write with each (`keys::respelled`) to a store whose root
names that key, and has it take the write as it was signed.
|
| |
|
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
|
| |
signature low-S
A key is `ssh-ed25519` or `ecdsa-sha2-nistp256`, spelled alike; an ECDSA signature is
over SHA-256, its `s` low and `r` and `s` SSH's shortest mpints, so that it is spelled
one way. The vectors and the agent test, among the harness's.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
| |
`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` 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` 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`).
|
| |
|
|
|
|
|
|
| |
`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.
|
| |
|
|
|
|
| |
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 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.
|
| |
|
|
|
|
| |
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.
|
| |
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
|
|
| |
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.
|