aboutsummaryrefslogtreecommitdiffstats
path: root/src/federation
Commit message (Collapse)AuthorAgeFilesLines
* federation: versions, their rules, and the paths they matchtv37 hours2-0/+539
| | | | | | | | | | | | | | | `Version::read` reads a version by itself, and says what makes one none (`docs/federation.md`, The policy): a field missing or more but for `checkpoint`, another federation, a number and `changes` that don't go together, keys and node lists not of the same parties, a party's name, its keys (one to 16, spelled as keys, none twice in the version) and its node list (up to 64 node IDs, none twice), checkpoint heads, and rules (a literal first segment and not `_continuum`, `{party}` once at most, `**` last only, a writer that is a party of it, `"{party}"` where the path holds `{party}`, or `false`; a path as a write's may be). `changes_validly` asks whether it changes another: one past its number, its hash, and each `since` its own number or the other's with the same keys, or node list. `writer` gives who writes at a path, by the first rule that matches; `only_moves_on` whether it changes nothing but its number, what it changes and its checkpoint.
* federation: keys, node IDs and signatures, each spelled one waytv37 hours2-0/+148
| | | | | | | | | | | A key is `ssh-ed25519`, one space, and its base64, padded and canonical, with no comment, its 32 bytes an Ed25519 public key; a node ID is spelled as continuum spells it, its key one too; and a signature is the SSHSIG blob of version 1 for the namespace `continuum-federation`, hashed with `sha512`, its reserved field empty, its key the event's, in base64, padded and canonical, unarmored, checked by continuum's strict check (`access::sshsig::verify_blob`) and read back to what `ssh-keygen` writes around it. `keys::sign` makes one, for clients and tests. Tests show each spelled otherwise taken for none.
* federation: JSON written one waytv37 hours2-0/+452
| | | | | | | | | | An event is the JCS encoding (RFC 8785) of a JSON object, within the limits federation 1 sets (`docs/federation.md`, Events). `jcs::read` gives the JSON bytes are only where they are what JCS writes of it: names sorted by their UTF-16 units and none twice, no whitespace, strings escaped as ECMAScript escapes them; and, beyond JCS, numbers only integers from −2⁵³ to 2⁵³, strings only whole Unicode characters, and objects and arrays nested up to 32 deep. Tests show what reads back and what is none, the order of names by UTF-16 units that byte order gets wrong, and the depth.
* store: a fork refuses what the store it came from builds on what its root keepstv38 hours1-1/+2
| | | | | | | The test of forks expected an event the store it came from took after the fork's heads to wait in the fork, but it builds on the put the fork's root keeps, which comes before the root, its one head: the fork refuses it, not above its root, as it refuses an event built on what a checkpoint keeps.
* store: the fold says how large an event may be, and the document judges by ittv38 hours3-1/+14
| | | | | | | | The document took any bytes that hash to their key, while the fold bounds events (the federation: 256 KiB): one change of any size filled every node until the next remake. How large an event may be is a question of the change alone, so the fold says it (`Fold::LARGEST`), the document refuses a change putting a larger one, and the store takes such bytes as none.
* federation: groups that parted come together as parties come in, not by mergestv38 hours3-61/+27
| | | | | | | | | | | | | A merge, a fork at heads of several stores, named every party's keys anew, so that a party wrote its key set again before anything a key of its set signed counted there; and kept each side's values side by side, so that a value a party replaced on one side came back where the other side's write had the lower ID. Letting the other side's parties in, by a version or a fork naming them, who sign again what they keep as a party's client signs again what a move refused, does the same with nothing new. So a fork is at heads of one store: the fold makes its root from that store's state, and the store from its own heads (`Store::fork`). Merges' rows go, those after them move up, and Roads not taken says why, with merging in place.
* store: properties over generated historiestv39 hours3-0/+444
| | | | | | | | | | | | | | | | | | | | Two to four writers, each knowing what it wrote and what was written when it last caught up with the others, write the test fold's events on one or two events they know. Eras and cuts are numbered by their history, each number written once, or, for some properties, as often as it comes. A store offered them is checked against the whole history, read from the root with nothing forgotten: * it holds the same whatever order the events come in: every order putting each after what it builds on, for up to six events; some shuffled beyond; and backwards, where every event waits until the first comes; * it judges every event as the whole history does, the store's own refusals aside; * what builds on a refused event is refused; * what it took is above its checkpoint's heads, the cut naming the checkpoint among it, and it reads as its checkpoint and what it took, and as its whole history; * a node starting from its checkpoint holds what it holds. A failing history is cut down, events taken out with what builds on them for as long as it still fails, and printed.
* store: the test fold judges a cut by the checkpoint current at its historytv39 hours1-23/+83
| | | | | | | | | | | | | | | | A cut names heads above those the latest cut of its history names, and holding that cut, or, where its history holds none after the checkpoint the state starts from, heads after that checkpoint or its own; as federation.md has a version name heads after the checkpoint current at its history, at which that one is current too. It judged them by the checkpoint the store holds, which isn't the one current at the history of a cut taken in the same offer as the cut before it, before the store moves. A cut is above its heads as store.md says, each of its dependencies one of them or above them, so that moving to them refuses none of what named them. Of a checkpoint's heads, whose history a state starting from it doesn't hold, it takes none as built on another, nor on what the checkpoint keeps: starting from a checkpoint at two heads, one of them kept, it took the other as built on it, and refused the cut naming them.
* store: what is above some heads names nothing before themtv39 hours1-0/+9
| | | | | | | | | An event above some heads has each of its dependencies among them or above them, not only them all in its history. The store holds after its checkpoint only events whose dependencies are its heads and the events after them, and so it holds every event above them: one naming an event before them as well is refused by a node that moved, and never taken by one starting from the checkpoint, which never held what it names. Tests show it for an event offered after the move and one taken before it.
* store: forks and mergestv39 hours1-0/+87
| | | | | | | | The fold makes a fork's root from the states at heads of one store, or of several, which merges them, and what makes the fork; the store gives it the states, and the events the root keeps, from the stores holding them. A node holding those heads checks a root by building it. A fork and the stores it came from take nothing of each other: what each writes after builds on what the other doesn't hold.
* store: moving to a checkpoint, and starting from a pinned onetv39 hours2-8/+235
| | | | | | | | | | | | | Once the fold names heads of a later checkpoint (events after the store's, none in another's history), the store builds the checkpoint at them, keeps what the fold keeps, forgets what came before them, and refuses every event not above them, with what waits on such an event. What it forgot is held as accounted for: brought again, it is held, and an event built on it isn't above the heads. A store starts from a checkpoint its operator pins, its events building on the heads the checkpoint was built at. A node starting from a checkpoint must judge the event that named it as every node does; the fold for the tests counts the heads of the checkpoint a state starts from as after the checkpoint current at them, so that it does.
* store: a node's own refusals, and its operator's dropstv39 hours1-0/+126
| | | | | | | | | | Where its history takes an event but the fold has the node refuse it by what it took before (the federation's second version changing one), the store refuses it as its own. An operator may have the node drop events taken after its checkpoint, with everything built on them, and refuse them from then on; what the checkpoint keeps, or holds by ID, isn't dropped, as every event after it builds on that. The operator takes either back by allowing it, and what was refused for being built on it, to be offered again. The fold for the tests shows both with its eras.
* store: a store held in memory, and a fold for its teststv39 hours3-0/+803
| | | | | | | | | | | | | | | A store starts from its root, with the events the root keeps, and holds the events taken after it. An event offered is taken once the store holds its dependencies, where it is above the store's heads (built on an event after them, or on all of them) and the fold takes it at its history: the state its history reads as, folded from the checkpoint. An event waits for what it builds on, and is taken when that comes; one built on a refused event, or whose bytes are none of the fold's, is refused, with what waits for it. The fold made for the tests judges by history (a put refused where its key is locked), reads by what counts (a key's latest put, then the lowest ID), refuses by what a node took before (two eras of one number), and moves to checkpoints (cuts), as the federation does, so that the later stages' tests have something to exercise.
* federation: the feature, and the store's foldtv39 hours2-0/+129
`federation`, a feature of its own, builds what `docs/federation.md` and `docs/store.md` design, stage by stage; without it continuum builds and behaves as it does. The aliases build with it, and `docs/development.md` says so. Its first part is the store's: an event's ID, the SHA-256 of its bytes written as 64 lower-case hex digits and read back only so, and the `Fold` trait as `docs/store.md` gives it. The trait reads a checkpoint's parts too, the heads it was built at and the events it keeps, which a node taking a pinned checkpoint needs; the design names it. Nothing uses either yet, but a test.