diff options
| author | tv <tv@krebsco.de> | 2026-11-15 18:43:13 +0000 |
|---|---|---|
| committer | tv <tv@krebsco.de> | 2026-11-15 18:43:13 +0000 |
| commit | f3bfea8ebda0fa7efe1fd9ed6fe670ddb544d38e (patch) | |
| tree | a5e8a6049dafd001fb52b0da5b7698e8a4f9dc70 /docs/access.md | |
| parent | 5866291a3752342ff954c39d728384dfe7ff02f8 (diff) | |
rules: the time before strict is the change that turned it, written again or not
A change written under a policy that isn't strict was refused, in a
strict document, unless it was in the history of the change that wrote
the policy value the document read now. So the policy written again by
a node that held a change from before, taken beside the strict policy,
put that change in the new writer's history: that node kept it, every
other node refused it, and the new policy with it, and the node was cut
off.
Now the reference is the change that turned the swarm strict: one that
wrote a strict policy where the policy at its history wasn't, found by
following back the writes of what the policy holds
(`store::writers`). A change written under a policy that isn't strict is
refused where such a change is beside it, neither in its history nor
built on it. A policy written again, strict over strict, names the same
change.
One turning the swarm strict beside it is refused like any other. Of
two at once neither is preferred: any rule choosing one, the lower hash
say, would let a change made later to look as old take the place of the
one every node took, and every node would drop it with all that was
built on it. So two members turning a swarm strict at once split the
nodes that took one from those that took the other; access.md says to
turn it from one.
Diffstat (limited to 'docs/access.md')
| -rw-r--r-- | docs/access.md | 15 |
1 files changed, 10 insertions, 5 deletions
diff --git a/docs/access.md b/docs/access.md index b64bd21..c4ce295 100644 --- a/docs/access.md +++ b/docs/access.md @@ -472,12 +472,17 @@ through a remake (Turning a swarm strict, below), which keeps only what an opera looked over. Writing the strict policy into it directly trusts it as it is: look it over first (`continuum-signed verify` on each entry). From then on nothing is added to the time before: a change written under a policy that isn't strict is refused, received -or held, unless it is in the history of the change that wrote the strict policy, so a -member can't plant at that time what nobody could follow; a node that took one beside -that change drops it once a peer tells it so (Changes judged on every node, below). A +or held, where the change that turned the swarm strict (that wrote the strict policy +under one that wasn't) is neither in its history nor built on it, so a member can't +plant at that time what nobody could follow; a node that took one beside that change +drops it once a peer tells it so (Changes judged on every node, below). The policy +written again later doesn't change which change that is. One written beside it is +refused like any other, even one turning the swarm strict too, so a change made later +to look as old can't take its place: two members turning a swarm strict at once split +the nodes that took one from those that took the other, so it is turned from one. A value there that isn't an envelope starts its chain anew: any envelope its user once -signed for that path replacing nothing (`prev` empty) can be put there again. Without the policy, signed values may -be written all the same, and plain ones too. +signed for that path replacing nothing (`prev` empty) can be put there again. Without +the policy, signed values may be written all the same, and plain ones too. Keep two users who may manage users, or two keys each: under a strict policy, a registry whose only manager lost its keys changes no more (the protocol writers do |
