| Commit message (Collapse) | Author | Age | Files | Lines |
| |
|
|
|
|
|
|
|
|
| |
In a swarm holding a store, a node reads a peer's messages only by the party its
handshake named. One whose handshake it hasn't taken (its reply lost, say) was cut off
at its next message, as a non-member is, while the peer, which took ours, synced on, and
neither said HELLO again. Now such a message goes unread, and the node says HELLO to the
peer, as to any whose reply it waits for (`hello_again_now`): its reply names its party.
What a peer refused as a non-member sends next is known to be a non-member's, its party
kept, so that it asks for no HELLO. A simulation loses a's replies to b for a while.
|
| |
|
|
|
|
|
|
|
| |
`federation_attack_33`: beside the fork a node holding the history makes, one whose root
leaves out tv's write, which counts at its heads. b, holding the history, builds the one
and not the other (`fork::check`). Each fork's founder starts its swarm from its root
and the events it keeps, and a node of lass joins each by its ID, taking it on its
operator's word, and reads what the root keeps: tv's write in the one, carried by the
changes founding its swarm, nothing in the other.
|
| |
|
|
|
|
|
| |
An ignored test prints, each by its hash and its bytes, the changes founding the swarm
of the vectors' first version's root, and those founding the fork whose root is the
fork vector's, keeping tv's write: Automerge encodes them, so no script apart computes
them, and they are fixed once printed by a run of this code.
|
| |
|
|
|
|
| |
A vector computed apart, as the others: the root of a fork of the vectors' first
version at tv's write, keeping it, by the version after the first; its bytes, read
back, and its ID.
|
| |
|
|
|
|
|
|
|
|
| |
other
A property over generated federations, honest ones: a fork at the heads of a history's
first half, by the version current there, numbered one past it and changing it. Its
root keeps what counts at those heads, the values at places and the members, with its
version current; it takes nothing else of the history; and the store it came from takes
nothing built on the fork's root (`docs/federation-tests.md`, Properties, Forks).
|
| |
|
|
|
|
|
|
| |
`root FILE`: the root of the federation whose first version the file holds, as the
file its founders start its swarm from (`--store-root`). `fork FILE HEAD...`: the root
of the fork at those heads by the version the file holds, with the events it keeps, as
a node holding the federation builds it (`POST /admin/events/fork`). `check FILE`: what
a node finds of the fork whose root the file holds (`POST /events/fork`).
|
| |
|
|
|
|
|
|
|
| |
`POST /admin/events/fork`: the root of the fork at the heads named by the version
given, as the node's store builds it, with the events it keeps, as the file the fork's
founders start its swarm from (`--store-root`). `POST /events/fork`: what the node finds
of the fork whose root the body holds: whether it builds that root at its heads, and
why not; what it holds that those heads lack; and the parties whose keys the fork's
version gives otherwise than they had there (`federation::fork`).
|
| |
|
|
|
|
|
|
|
|
| |
`federation::fork`: a node holding a federation's history makes the root of a fork at
heads it holds by a version, with the events the root keeps, as the file the fork's
founders start its swarm from (`make`, `root_file`, which `--store-root` reads); and
checks a fork's root it is given (`check`): whether it builds that root at its heads,
byte for byte, what it holds that those heads lack, and, party by party, the keys the
fork's version gives where they aren't those the party had there. The attack rows 35
and 36 have their tests.
|
| |
|
|
|
|
|
| |
The file `--store-root` names holds the store's root on its first line, and, for a
fork, the events the root keeps, each on a line of its own (JCS writes no line break).
The node checks that the federation takes them as a store's root with what it keeps,
and starts from the changes founding the swarm, built from them.
|
| |
|
|
|
|
|
|
|
| |
keeps
A node reads its store from a fork's root and the events the root keeps, which follow
it in the document, once they are all there; until then it holds no store. Its store
takes what builds on the fork's root, and nothing the store it came from took after
the heads it forked at.
|
| |
|
|
|
|
|
|
|
|
|
| |
for byte
A change of a swarm holding a store naming no node is taken where it is one of those
founding the swarm (`events::is_founding`): built from the root its document holds and
the events the root keeps, those at its history and those it puts, by the fold
(`access::holding`). A change of the genesis change's writer waits for no signature,
as every node builds it and nobody signs it (`screen::built_by_every_node`); judged, it
is refused unless it is one of them.
|
| |
|
|
|
|
|
|
|
|
|
| |
it keeps
A fork's root keeps events (`docs/store.md`, On Automerge): they follow its genesis
change in changes of the same writer, built the same way, filled in the order of their
IDs, events going into a change until their bytes there reach 1 MiB, the next event
beginning the next change (`events::founding`). A swarm holding a store starts from all
of them (`events::started`, given the events the root keeps; none for a federation's
root).
|
| |
|
|
|
|
|
|
| |
`federation_attack_59`: a for tv and b for lass, apart, each propose a checkpoint once
their stores took six events, and back it; c votes for makefu, following tv; each votes
`false` on a checkpoint beside the one it backs (`--store-nay-beside`). a and b,
together, vote `false` on each other's: the votes split. With c, tv's passes and every
node moves there; lass's is dead by the nays of tv and makefu, which their records hold.
|
| |
|
|
|
|
|
|
|
|
| |
backs
`--store-nay-beside`, for a node voting by itself: where its party backs a proposal on
the current version that can still pass, by its record or by what it votes now, it
votes `false` on every other proposal there that only moves to a checkpoint and can
still pass, once. So, of two checkpoints proposed at once, the one it doesn't back
dies, and its backers are free (`docs/federation.md`, Votes a node casts by itself).
|
| |
|
|
|
|
|
|
|
| |
One check of an attack table (`harness::every_row_has_its_test`), for the federation's
and the store's: every row has its test among the sources of its kind, unit tests or
the simulations (`simtest::holding`), but for the rows whose tests wait for later; a row
marked `—` has none; no test names a row that isn't there, nor two tests one row. The
rows waiting: forks, the remakes, flooding, what a node, a client or a tool does that
isn't built yet, and a rule for two checkpoints proposed at once.
|
| |
|
|
|
|
|
| |
`store_attack_10`: x1 and x2, tv's, start apart from one document under one writer,
and each puts an event: changes of one writer at one number. Together, the documents
part, each refusing the other's changes for good; the events reach every node, put
again from the changes refused, and every node reads the same.
|
| |
|
|
|
|
|
| |
`store_attack_19`: makefu lists five nodes, tv two, and lass one, whose operator names
tv's too (`--store-neighbour-parties`); each node keeps two neighbours by the graph
among all members. a and b keep each other, and c one of them, whatever makefu's nodes
are. The simulations' nodes started from the root may have their configuration adjusted.
|
| |
|
|
|
|
|
|
| |
`federation_attack_67`: makefu proposes a version and backs it alone. a votes for tv by
itself, proposing a checkpoint once its store took five events; b votes for lass,
following tv; each with its party's record, begun before the federation. a proposes a
checkpoint beside makefu's proposal, b backs it, a node writes it as it passed, and
every node moves there.
|
| |
|
|
|
|
|
|
| |
`federation_attack_49`: tv backs a proposal of its own with lass, and one of lass's
with makefu; b, apart, takes the other version than a and c. Together, they stay
parted, each keeping the version it took. b's operator has it drop what it took and
take the other side's (`Holding::drop_taken`, `allow`); or, where the versions named
checkpoints, starts it again from the checkpoint the others moved to, pinned. No fork.
|
| |
|
|
|
|
|
|
| |
`store_attack_24`: c is away while a and b take a version passing on tv's and lass's
votes that only moves to a checkpoint, move there, forget what came before, and take a
write after it. Back, c builds the checkpoint from the document, which holds what came
before, and reads what a and b read. What happens after a remake leaving it out comes
with the remakes.
|
| |
|
|
|
|
|
|
|
| |
`federation_attack_28`: tv, lass and makefu, a node each, apart while each is given its
own: two writes of tv's at one place, a write of lass's, and a proposal and the votes
that pass it, each on another node. Apart, each reads its own; together, they read the
same, the version that passed current, written by whichever node held it passed. The
simulations of swarms holding a store share their federation, their nodes started from
its root, and what they read of a node's store.
|
| |
|
|
|
|
|
|
|
| |
Once a proposal passed on the current version, as the node's store reads, the node
writes it by a version event (`State::version_event`): on the `true` votes of the first
parties by name that pass it, each party's of the lowest ID, so that nodes holding
those votes write the same bytes, one event. It offers the event to its store first and
puts it only where it is taken: of two passing at once, it writes the one it takes, and
refuses the other as its own (`Holding::passed`, run by the store's worker).
|
| |
|
|
|
|
| |
Picked where the path goes, rustc 1.95 takes the pick's type from that place, a slice
of strings, and refuses the paths offered: picked by itself, as `rng.pick(&KEYS)` is,
it is one of the paths, which goes where a slice of strings does.
|
| |
|
|
|
|
| |
The closed paths a generated write picks one of are an array of their own, and the
events a node put a slice: picked from an array written in place, a path's type is
left to be inferred from where it goes, which some compilers don't.
|
| |
|
|
|
|
|
| |
tv lists a and b, which start from the store's root; lass lists c, which joins by the
store's ID; d is of lass too, which doesn't list it. Events put on a and on c reach a,
b and c, which read them; d, which no member syncs with, gets nothing. A simulated node
started on a document expects its swarm, as `run` has it do.
|
| |
|
|
|
| |
`Spec::root`: the root whose first version a spec spells out, built in one place for
the tests of the attacks, of the store read from a document, and the properties.
|
| |
|
|
|
|
|
|
|
| |
Three nodes write at random: events at their IDs, larger than the fold allows or not,
again, or at other keys; strings and maps under the events; deletions; their entries
or others'; and what is closed. Each now and then catches up with a node that takes
their changes as it receives them (`screen::apply_bytes`). What it takes leaves at
every key under `_continuum/events` the bytes whose ID it is, the root's among them;
its document saves and loads; and another node, given all it took, takes it all.
|
| |
|
|
|
|
|
|
|
|
| |
alone holds
A property over generated federations, honest ones with checkpoints: their events are
put into a document by two writers, in batches of a shuffled order, some by both at
once, the writers merging now and then; a node reads its store from each writer's
document as it grows, and once more after both merged. Each holds what a store given
the events alone holds: its checkpoint, the events it took after it, and what it reads.
|
| |
|
|
|
|
|
|
|
| |
Each row of `docs/store.md`, Attacks, marked unit has its test,
`store_attack_<row>`: where it is judged (`access::holding`, `access::token`), where
the store held in memory meets it (`federation::store::memory`), and where a node reads
its store from its document (`federation::held`). Tests that checked a row already take
its name; a check reads the doc's rows and fails on a unit row without its test, but for
rows 21 and 22, which the remakes bring.
|
| |
|
|
|
|
|
| |
A party that has a node vote by itself votes by hand only through that node:
`continuum-party vote PROPOSAL yes|no --through` asks the node to cast it
(`POST /admin/events/vote`), by the record the node keeps, without a key or record of
the client's own.
|
| |
|
|
|
|
|
|
|
|
| |
A party that has a node vote by itself votes by hand only through that node, which
keeps its one record (`docs/federation.md`, Votes a node casts by itself):
`POST /admin/events/vote`, `{"proposal": <hash>, "yes": <bool>}`, by the record and, with
a `true`, by the voters' rule; signed with the party's key the node keeps, recorded, and
put. Refused (`422`) where the record or the rule forbids it, or the node votes for no
party. Putting an event through the API puts it into the document as the node's own
votes are put (`held::write`).
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
A node may vote and propose for its party by itself, by its operator's rules
(`docs/federation.md`, Votes a node casts by itself; `federation::vote`):
* `--store-vote-key`: the party's key it signs with, an OpenSSH private key file, one
the party's version names, kept on the node;
* `--store-vote-record`: its party's one record of its votes, which it votes by, written
before each vote is sent, begun where there is none on the version current then;
* `--store-follow`, `--store-follow-any`: the parties it follows, by default only on a
version that only moves to a checkpoint;
* `--store-propose-events`, `--store-propose-every`: when it proposes a checkpoint, once
it holds so many events beyond its checkpoint, or so long after its store moved there;
* `--store-held-for` (10 minutes): how long it holds an event before it holds it for a
while, for the heads it proposes and the voters' rule.
Its store keeps when, by the node's own clock, it took each event, and when it moved to
its checkpoint. Whenever the worker reads the store, the node decides what to sign
(`Holding::act`), records it, writes the record, offers it to its store, and puts it
into the document (`held::write`). A vote by hand through the node, by the record and
the voters' rule, is `Holding::vote_by_hand`.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
A party may have one of its nodes vote and propose for it, by rules its operator sets
(`docs/federation.md`, Votes a node casts by itself): `federation::vote::decide`, from
the node's store, how long it held each event, and its party's record.
* Following: `true` on a proposal on the current version where a party it follows voted
`true`, `false` where one voted `false`; by default only on a version that only moves
to a checkpoint, a `true` as a `false`.
* Proposing a checkpoint: once so many events are held beyond its checkpoint, or so long
after the store moved there, a version that only moves to a checkpoint at the heads of
what it held for a while, at which the current version is current; only where nothing
that can still pass is proposed on the current version, but a proposal it wouldn't
back that nobody backs but its proposer. It backs what it proposes.
It keeps to what a party's client keeps to (`Record::may_vote`), one `true` at a time;
and by the voters' rule (`vote::backs_checkpoint`) backs a version naming a checkpoint
only where it changes nothing of the current one but its number, what it changes and
its checkpoint, and its heads leave out nothing it held for a while before it was
proposed.
A party that has a node vote by itself votes by hand only through that node, which keeps
its one record: `vote::by_hand` decides such a vote by the record and, with a `true`, by
the voters' rule.
|
| |
|
|
|
|
|
| |
A voter backs a checkpoint only where everything it held for a while before it was
proposed is among its heads, in their history, or above them (`docs/federation.md`,
Checkpoints): `Store::left_out` names, of events a store took, those a checkpoint at
given heads leaves out.
|
| |
|
|
|
|
|
| |
The federation's design says what of it is built: the store in a swarm's document,
members by the federation and the store at a node's API, as the store's design says; and
a party's client, which signs its party's events, votes by its record, signs again what
a move refused, and names a party that voted twice.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
A second binary, behind the `federation` feature: a party's client, which signs its
party's events with one of its keys (`--key`, an OpenSSH private key file), puts them
through a node's API (`--node`, its user and password in the URL, or `--token`), and
keeps its party's record (`--record`), by which it votes, written before a vote is
sent (`federation::party`, run by `continuum::party`):
* `init PARTY` begins a record of `PARTY` on the version current now;
* `write PATH VALUE`, `keys KEY...`, `nodes NODE...` and `propose FILE` sign events on
the node's heads, recorded, and put;
* `vote PROPOSAL yes|no` votes on the proposal of that hash on the current version, by
the record: with a `true`, the votes on its party's earlier proposal, from the node,
checked, kept as the nays that freed it;
* `again` signs again, of the latest event it signed at each place, its key set and its
node list, what the node refuses as not above its checkpoint's heads, or as built on
one it refuses;
* `twice RECORD...` names, from the records of parties' clients, a party that voted
twice.
The feature brings reqwest along, the client's HTTP.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
A party's client signs its party's events with one of its keys, read from an OpenSSH
private key file, unencrypted (`client::signing_key`), and keeps its party's record
(`client::Record`): the votes it cast, each as signed, with the versions they are on;
with each `true`, the votes that made its party's earlier proposal on that version dead,
as signed; and the events it signed besides. The record begins on the version current
then, and casts nothing on it; it is written whole or not at all.
It votes by its record, never by what a node shows (`docs/federation.md`, Changing the
policy): never `true` and `false` on one proposal, nor the same twice; a `true` only for
a version changing the current one, and one at a time, its earlier `true` on a proposal
the votes given make dead, each checked from itself and its version, which it keeps. It
signs again, of the latest event it signed at each place, its key set and its node list,
what a move refused (`Record::again`). And over the records parties' clients keep, it
names a party that voted twice (`client::voted_twice`): its `true` and `false` on one
proposal, or its `true` on two of one version, neither dead by all the votes.
JSON is taken as the federation takes it (`client::json`).
|
| |
|
|
|
|
| |
`GET /events/refused` says of each refusal its kind (`none`, `judged`, `builtOn`, with
the event it builds on, or `notAbove`), apart from why: a party's client signs again
what a move refused, which it tells so.
|
| |
|
|
|
|
|
| |
A party's client votes by the record it keeps, and keeps the votes that made its party's
earlier proposal dead; it reads them from a node, and checks them itself, as each is
signed. `GET /events/counts` names the proposals on the current version, by their hash,
each with the events proposing it and the votes on it, by ID (`State::ballots`).
|
| |
|
|
|
|
|
| |
What makes a signed event (`event::signed`) and what each does (`write`, `keys`, `nodes`,
`proposal`, `vote`), and a version event (`event::version_event`), move from the tests'
harness into `federation::event`, for a party's client to make them as the tests do: the
harness makes its events through them.
|
| |
|
|
|
|
|
|
| |
Everything the node is moves from the binary into a library (`src/lib.rs`), so that
other binaries can use it: a party's client of a federation next. The node's binary
(`src/main.rs`) runs it (`continuum::run`), which wires things together as `main` did.
The library's doc comments are prose, not examples to test (`doctest = false`); its
tests are the library's, as `cargo quick` and `cargo sim` run them.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
Behind the `federation` feature, a node of a swarm holding a store has, at its API
(`docs/store.md`, Members; `docs/openapi.yaml`, Events):
* `GET /events`: its store's ID, its checkpoint's, its heads, and how many events it took
after its checkpoint;
* `POST /events`: an event put, whoever signed it, offered to the store and written into
the document at its ID unless the store refuses it (`422`, with why): taken, held, or
waiting for what it builds on;
* `GET /events/{id}`: an event the store holds, or its checkpoint, as its bytes;
* `GET /events/counts`: what counts as the store reads now: the current version, each
party's keys and nodes, the values at places, the members;
* `GET /events/refused`: what the store refused, its own refusals apart, its operator's
drops, and the rest with why;
* `POST /admin/events/drop` and `/admin/events/allow`: its operator has it drop what it
took, and take it back.
The events' endpoints are anyone's this node lets in, as the store's are; dropping and
taking back need `write` on `_continuum`, as what operators do. While a node holds no
store, they answer `404`.
|
| |
|
|
|
|
|
|
|
|
| |
A node's store takes events from elsewhere than its document too: one put at its API is
offered to it first (`Holding::offer`), to say what became of it. Its operator has it
drop events it took after its checkpoint, with everything built on them
(`Holding::drop_taken`), and takes them back (`Holding::allow`), the document's events
then offered again (`docs/store.md`, A node's own). After each, what the node keeps of
its own is written to its file where it changed, and the members are as the store reads
now.
|
| |
|
|
|
|
|
|
| |
At its API, a node of a swarm holding a store takes no token another node issued
(`docs/store.md`, Members): whoever its operator lets in may use it, and its operator
lets in nobody through another node. A token every node of a swarm takes would let
whoever another operator let in in here too. `token::issued_here` refuses such a token
(`ElsewhereIssued`), behind the `federation` feature.
|
| |
|
|
|
|
|
|
|
|
| |
named
A node of a swarm holding a store keeps some of its neighbours among the members of its
own party and of the parties its operator names (`--store-neighbour-parties`), so that a
party listing many nodes can't be all of them (`docs/store.md`, Members): its neighbours
by the shared graph among those members alone, each as its entry names it, which every
node of its party computes alike, with those among all members.
|
| |
|
|
|
|
|
| |
In a swarm holding a store, a node computes its neighbours, and the member list's graph
writers' trees are built on, from the members its store names, each with the party its
entry names (`docs/store.md`, Members): the other entries name nodes it doesn't sync
with. While it holds no store, from every entry, as elsewhere.
|
| |
|
|
|
|
|
|
|
|
|
|
| |
A node of a swarm holding a store syncs with its members only (`docs/store.md`,
Members): the nodes its store names, each with the party its handshakes name, as the
store reads now. A handshake from any other goes unanswered, and what the node had with
it ends, as with a banned node; so does what it had with a member at its next message,
once the store names it no more (`swarm::peer::members`). The party a handshake names is
kept with the peer. While a node holds no store yet, joining, it can't tell, and takes
everyone of its swarm: its seeds, which take it only where its party lists it.
A node says whether it is a member itself, as its store reads, when that changes.
|
| |
|
|
|
|
|
| |
In a swarm holding a store, a node's handshakes name the party it is of (`docs/store.md`,
Members), so that a peer tells whether it is a member before its entry reaches it: HELLO
and HELLO_REPLY carry `party`, as `--store-party` says, None elsewhere and without the
`federation` feature. Wire format version 52.
|
| |
|
|
|
|
|
|
| |
The fold names the members, each with its group: for the federation, the nodes each
party lists, each as its party's (`docs/store.md`, Members). A node keeps them as its
store reads now, apart from the store, so that whoever asks doesn't wait while the store
takes events: `Holding::member` tells whether a node, of a party, is one, or that the
node holds no store and can't tell; `Holding::members` lists them.
|
| |
|
|
|
|
|
| |
In a swarm holding a store, a node's own entry names the party it is of (`docs/store.md`,
Members): `party`, as `--store-party` says, written at registration and kept so when it
changes over a restart, as the alias is; `members::party` reads it. Behind the
`federation` feature.
|