| Commit message (Collapse) | Author | Age | Files | Lines |
| |
|
|
|
|
|
|
|
|
|
|
|
| |
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 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.
|
| |
|
|
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
|
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
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.
|