| Commit message (Collapse) | Author | Age | Files | Lines |
| |
|
|
|
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
|
|
| |
A node's group is its operator's, in its configuration (`docs/store.md`, Members):
`--store-party NAME`, which `--store-root` and `--store-id` need, a party's name as the
federation spells one. The node keeps it with its store (`Holding::party`), to name it
in its entry and its handshakes. The options of a node of a swarm holding a store
(`--store-file`, `--store-checkpoint`, `--store-party`) set without either are refused
together.
|
| |
|
|
|
|
|
|
|
|
|
| |
Once a store moved to a checkpoint, a node reading it from the root could take what was
grown anew from the root since, by keys of versions long replaced: so its operator pins
the checkpoint (`--store-checkpoint`, by its ID), and the node reads its store from
there whenever it starts (`docs/store.md`, Pinned checkpoints). It finds it in its
document: at heads a proposal's version names, built from their history read from the
root, as any node builds the checkpoint it moves to (`Store::checkpoint_at`), the one
whose ID is pinned. Until the document holds it, the node holds no store, and says so
once.
|
| |
|
|
|
|
|
|
|
|
|
|
| |
A node puts again, in changes of its own, every event its store holds that its
document lacks (`docs/store.md`, What the store takes from the document): one it took
from the document it left, at a drop or a rejoin, or from a change it refused, whose
events the store is offered as from anywhere (`Holding::look`, every few seconds, of the
changes screening keeps). It puts each after its dependencies, what the checkpoint keeps
first, then what the store took after it in the order taken, up to 1 MiB of events a
change, once a wait of its own has passed: random, between one and ten seconds after
the document first lacked them, so that not every node puts the same, and none another
node put meanwhile, as it looks again when it writes.
|
|
|
A node of a swarm holding a store holds the store, read from its document
(`docs/store.md`, What the store takes from the document): `federation::held`. Whenever
the document changes, a worker reads the events it holds that the store wasn't offered
from it, under the document's lock, and offers them to the store without it, each taken
as from anywhere: once its dependencies are held, judged at its history. Another
document (a drop, a rejoin) is read as it comes, the store going on.
The node reads its store anew from its document whenever it starts, from the root, by
what is its own of it: the events it refused by what it took before, and those its
operator had it drop, which it keeps in a file (`--store-file`), written whenever that
changes, so that a store read anew in another order refuses what it refused before. A
file that doesn't read stops the node from starting; without one, a restart may take
what it refused.
|