| Commit message (Collapse) | Author | Age | Files | Lines |
| |
|
|
|
|
| |
A swarm holding a store names its fold in its policy, `{"version": 2, "store":
"<fold>"}`: the fold's name is a constant of the fold, `federation` for the federation and
`test` for the fold made for the store's tests.
|
| |
|
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
|
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
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`, 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.
|