aboutsummaryrefslogtreecommitdiffstats
path: root/src
Commit message (Collapse)AuthorAgeFilesLines
* peer: a member's message before its handshake was taken asks for onetv18 hours2-6/+76
| | | | | | | | | | 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.
* simtest: a fork whose root doesn't read as its heads do, found by who holds themtv18 hours2-4/+103
| | | | | | | | | `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.
* federation: the changes founding a swarm printed, to be fixed as vectorstv18 hours1-0/+41
| | | | | | | 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.
* federation: a fork's root and its ID, fixedtv18 hours1-0/+21
| | | | | | 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.
* federation: a fork keeps what counts at its heads, and takes nothing of the ↵tv18 hours1-0/+62
| | | | | | | | | | 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).
* continuum-party: a federation's root, a fork's made through a node, and checkedtv18 hours1-6/+110
| | | | | | | | `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`).
* api: a fork's root made, and what a node finds of onetv18 hours1-12/+78
| | | | | | | | | `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: a fork's root made, and checked by a node holding its historytv18 hours4-18/+213
| | | | | | | | | | `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.
* node: `--store-root` holding a fork's root and the events it keepstv18 hours2-12/+57
| | | | | | | 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.
* federation: a fork's store read from its document, with the events its root ↵tv18 hours1-1/+49
| | | | | | | | | 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.
* access: the changes founding a fork's swarm taken, unsigned, as built byte ↵tv18 hours3-6/+195
| | | | | | | | | | | 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.
* document: the changes founding a fork's swarm, built from its root and what ↵tv18 hours7-26/+105
| | | | | | | | | | | 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).
* simtest: two checkpoints proposed at once, the one not backed dying by the naystv18 hours2-3/+136
| | | | | | | | `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.
* federation: a rule voting `false` on a checkpoint proposed beside one a node ↵tv18 hours4-0/+163
| | | | | | | | | | 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).
* federation: each attack table checked whole, its rows marked sim tootv19 hours3-94/+101
| | | | | | | | | 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.
* simtest: a writer forked, its events reaching both sidestv19 hours1-0/+59
| | | | | | | `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.
* simtest: a group naming many nodes is not every node's neighbourstv19 hours1-1/+51
| | | | | | | `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.
* simtest: a proposal kept alive by its proposer alone holds back no checkpointtv19 hours1-1/+79
| | | | | | | | `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.
* simtest: keys voting twice part honest nodes; their operators bring them backtv19 hours1-0/+110
| | | | | | | | `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.
* simtest: a node away while the others moved to a checkpointtv19 hours1-0/+88
| | | | | | | | `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.
* simtest: different events to different peers, read alike once togethertv19 hours1-37/+205
| | | | | | | | | `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.
* federation: a node writes a version as soon as it holds it passedtv19 hours2-5/+119
| | | | | | | | | 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).
* access: a generated change's closed path, picked by itselftv20 hours1-1/+2
| | | | | | 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.
* access: what a generated change picks from, given its typetv20 hours1-7/+6
| | | | | | 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.
* simtest: a swarm holding a store, its members and a node its party doesn't listtv20 hours2-0/+109
| | | | | | | 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.
* federation: the tests' harness builds a federation's roottv20 hours4-45/+26
| | | | | `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.
* access: what a node of a swarm holding a store takes leaves its events soundtv20 hours1-0/+143
| | | | | | | | | 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.
* federation: a store read from its document holds what one given the events ↵tv20 hours1-28/+83
| | | | | | | | | | 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.
* store: a test per attack row marked unittv20 hours5-46/+355
| | | | | | | | | 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.
* continuum-party: a vote through the node that votes for the partytv20 hours1-2/+31
| | | | | | | 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.
* api: a vote by hand, through the node that votes for its partytv20 hours1-22/+33
| | | | | | | | | | 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`).
* node: votes it casts by itself, for its partytv20 hours3-7/+380
| | | | | | | | | | | | | | | | | | | | | | 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`.
* federation: what a node voting by itself decidestv20 hours2-0/+514
| | | | | | | | | | | | | | | | | | | | | | | | | 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.
* store: what heads leave outtv20 hours1-0/+41
| | | | | | | 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.
* docs: what of the federation is builttv21 hours1-3/+4
| | | | | | | 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.
* continuum-party: a party's client of a federationtv21 hours4-1/+475
| | | | | | | | | | | | | | | | | | | | | | 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.
* federation: what a party's client decides bytv21 hours2-0/+639
| | | | | | | | | | | | | | | | | | | | 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`).
* api: what the store refused, by kindtv21 hours1-2/+22
| | | | | | `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.
* api: what counts names the proposals on the current version, and their votestv21 hours2-1/+62
| | | | | | | 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`).
* federation: events made, as a party's client makes themtv21 hours2-48/+87
| | | | | | | 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.
* continuum is a librarytv21 hours2-504/+510
| | | | | | | | 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.
* api: a swarm holding a store at a node's APItv21 hours3-1/+280
| | | | | | | | | | | | | | | | | | | | | | 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`.
* federation: events offered to a node's store, and its operator's dropstv21 hours2-2/+84
| | | | | | | | | | 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.
* api: in a swarm holding a store, a node takes no token another issuedtv22 hours2-1/+48
| | | | | | | | 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.
* topology: neighbours among the members of a node's own party, and of parties ↵tv22 hours4-1/+100
| | | | | | | | | | 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.
* topology: in a swarm holding a store, neighbours among its memberstv22 hours1-0/+25
| | | | | | | 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.
* peer: in a swarm holding a store, its members onlytv22 hours5-0/+94
| | | | | | | | | | | | 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.
* handshake: the party its sender is oftv22 hours4-3/+33
| | | | | | | 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.
* federation: the members a node's store namestv22 hours1-2/+34
| | | | | | | | 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.
* members: a node's entry names its partytv22 hours1-1/+42
| | | | | | | 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.