diff options
| -rw-r--r-- | docs/federation.md | 169 |
1 files changed, 79 insertions, 90 deletions
diff --git a/docs/federation.md b/docs/federation.md index 9e389af..9b12c55 100644 --- a/docs/federation.md +++ b/docs/federation.md @@ -50,6 +50,12 @@ Out of scope: keeping the registry from being read (every party reads all of it) hiding who talks to whom, and a party's own machine taken over whole (then the adversary is that party). +The design asks one thing: that an honest federation bears whatever the malicious +do. It rules nothing about what happens on a party's own nodes, which nobody could +enforce: whom an operator lets in, what it lets them do, what it leaves out when it +reads. What it sees to is that nothing coming from any node breaks a promise for +the others. + ## What is promised To an honest node, whatever the others do, with any number of them malicious (3 to 5 @@ -212,7 +218,7 @@ value: | `limits.keys` | 64 | keys a user has at once | | `limits.nodes` | 64 | nodes carrying for a user at once | | `limits.users` | 16 | users a user created that stand; a root: no limit | -| `limits.vouches`, `limits.bans` | 64 | vouches, and bans, of a user that stand | +| `limits.vouches` | 64 | vouches of a user that stand | | `limits.proposals` | 8 | proposals of a user that are open | | `limits.writers` | 1024 | writers a party's nodes start in an epoch before more are put off | | `limits.name` | 255 | bytes of a name | @@ -254,8 +260,7 @@ grows. A statement is signed by one user and says one thing: | `key` | the user | one more key | | `retire` | the user | a key, and the cut after which what it signed doesn't count | | `node` | the user | a node that carries for it; or one that stops, with a cut | -| `release` | the user | a claim, a vote, a proposal or a ban of its own given up; or itself | -| `ban` | the user | a user that doesn't count for it, with a cut (Bans) | +| `release` | the user | a claim, a vote or a proposal of its own given up; or itself | | `claim` | the user | a name it wants (Claims; in the name's own register) | | `propose`, `vote` | a voter (a fork: any user) | Decisions | @@ -323,7 +328,7 @@ grows. A statement is signed by one user and says one thing: claim gives way to what was claimed in sight of it meanwhile (Claims). It doesn't count while it is past its limit. The limit is the one that holds where the registry is read: lowered, it leaves out the last. So for every limit: keys beyond - the first, nodes, creations, vouches, bans, proposals, a kind's claims. + the first, nodes, creations, vouches, proposals, a kind's claims. * **Names** of users are 1 to 64 of `A-Z a-z 0-9 . _ @ -`, as today, less the top-level keys the swarm uses otherwise (`_continuum`). Which of them may be created, and by whom, the kind `user` says (Claims). @@ -369,14 +374,16 @@ for its whole epoch. What sets a root apart: alone puts out a user the root change holds. * Its nodes' changes witness every claim, which is what settles one. * It creates users without a limit. What is the seats' counts toward nobody's limit. -* It holds the names a rule gives to a root, while it holds its seat: one that - leaves its seat leaves them to the roots, to claim. +* It holds the names a rule gives to a root, while it holds its seat. A remake that + leaves a root out says which root has each of them from then on: its claim is + made over, and no such name is ever without a holder. What a user signed before it + was a root stays its own. A root can't write in another's namespace, nor take a name that is final. It can contest any name that isn't, in the open. With several roots, any one that is up settles claims, any one that lies contests them, and none takes a name alone. A root -that is away, or turns on the others, is banned by the parties it harms (Bans), and -left out by the voters at the next remake; what is final stays as it is meanwhile. +that is away, or turns on the others, is left out by the voters at the next remake; +what is final stays as it is meanwhile. ### Lengths of time @@ -466,8 +473,8 @@ and for good: every line passes one. **Nobody is put out by a vote.** A user is in while one user that counts vouches for it, and no decision changes that. Against a user that keeps within the rules and harms all the same (squats names up to its limits, gets others' names contested) -there is: each party's ban, which changes what that party reads (Bans); the voters -saying who has a contested name; its vouchers unvouching it; and a root unvouching +there is: the voters saying who has a contested name; its vouchers unvouching it; +and a root unvouching the user it created above it, with all below, who then need other vouches. A vouch from anyone brings it back. @@ -647,7 +654,7 @@ So within a minute a name is its claimant's against any claim that says it saw nothing, as far as a root's node had the claim first. And within `final` against everything else: until then a root can still contest it, in the open, and so can whoever hands a node of a root or of the claimant a rival before the claim. A root -that does is banned, and left out at the next remake. +that does is left out at the next remake. A user's name is claimed the same way: the `create` statement is the claim, its side the nodes of its creator, of the new user and of the roots. Two creations of one @@ -710,28 +717,16 @@ a first key. A cut reaches no further back than the epoch (Remakes). -### Bans: for those who follow - -A user may state that another doesn't count for it, from a cut on: `ban`, which a -`release` of it ends. A node resolves with the bans of the users it **follows** -(`--follow`; its own user by default): what the banned user signed and what its nodes -committed outside the cut is left out, as a holder and as a witness. Bans are taken -in the order they were made; of two made out of each other's sight, the one by the -user with the shorter line to a root first, then by digest; and none by a user that -a ban taken before leaves out. A node that follows several users (the roots, for -files a whole network reads) takes a ban only where most of those it follows state -it: else one of them, banning the others first, would decide alone what all read. - -A ban changes what a node reads and writes out, never what it takes or refuses: every -node still holds every valid change, so banning splits nothing. It is what a party -does about a user it can't unvouch: one that squats, a root that contests its names -or that it no longer trusts. Its registry goes on without them. Parties following the -same users read the same registry. A node refuses its own user's write that only its -bans make valid (a claim of a name the banned user holds): the others would refuse -it, and everything the node writes after. +### Leaving a user out when reading -This is the trust root a user has beyond the swarm's: the root every node is given, -and whom it follows. In a dispute, the nodes following a user read its side. +A side note, since it is no part of the design: nothing here lets the swarm bar a +user, and nobody is put out by a vote. What a party does about a user it can't +unvouch (one that squats, a root that contests its names) is its own: whoever reads +the registry may leave out whom it likes, from where it likes, and reads on without +them. That changes nothing any node takes or refuses, so it splits nothing; it also +means two parties that leave out differently read two registries where a name is +contested. A node bars no node for the swarm either: it stops its own with a cut, +and refuses as peers whom its operator says. ### Decisions @@ -890,8 +885,9 @@ else: what the next epoch holds isn't voted on. It is the registry as it resolve which every node works out itself. * **The proposal** lists the voters of the next epoch by their IDs, names its roots - (those there are, unless it names others), and names the node of its proposer - that is to be its **coordinator**. It is voted on like anything else. + (those there are, unless it names others; and for a root it leaves out, which root + has each name a rule gives a root), and names the node of its proposer that is to be + its **coordinator**. It is voted on like anything else. * **The base.** Once the coordinator holds the votes it names the base in its record: the base is that record's history. * **One base an epoch.** A voter's node takes a remake up with its base: once the @@ -924,7 +920,7 @@ which every node works out itself. claims of a name rests on: which gives way to which, which is late against which, which is settled, which final; * the values in the namespaces that count, as the envelopes they are; - * the bans that stand, and what is uncovered and not dropped; + * what is uncovered and not dropped; * the proposals that are open, with their votes; * the member entries of the nodes that carry for a user it holds, and the epochs' metadata, as today; @@ -1197,7 +1193,7 @@ A change is valid if, in the document at its dependencies: 5. A `create`: its name is one the kind `user` takes, has no creation there that stands, a rule of the kind lets the signer, and the signer isn't past its limit there; or it is a root's, for a user the root change holds, that has no keys there. - `key`, `node`, `vouch`, `ban`: not past their limits there; a `vouch` for a user + `key`, `node`, `vouch`: not past their limits there; a `vouch` for a user that isn't gone there. `unvouch`: by the signer of what it takes back, or by a root for what is the seats'. `retire`, a node stopping: by a key above, or by the key itself as said under Cuts, the cut in the change's history, and its list what the @@ -1228,7 +1224,7 @@ Where a rule goes by a user's name (6, 7) and the name has several creations the user that lost it, as far as the change's history shows (another remains, Two claims), is refused; while none remains, each of them may write. So a user whose late creation of a name is known can't scribble over the namespace, and one whose name a liar got -contested goes on writing, for those who ban the liar to read. +contested goes on writing, for those who leave the liar out to read. Judging reads the registers at the change's dependencies, and nothing else: no cut is applied beyond a retiring or an unvouch that is there; who is gone is as the stamps @@ -1239,7 +1235,7 @@ valid when it was taken, so judging the next needs no look further back. ### Resolving The **resolved registry** is a function of a set of changes that holds each change's -history (and, for reading, of the users followed). In five steps, each reading only +history. In five steps, each reading only the steps before: 1. **Decisions.** Which proposals are decided, and which decision of each matter @@ -1249,21 +1245,19 @@ the steps before: back along the history and ends, and nothing below changes it. 2. **Who counts, and where.** The roots count, by their seats; a user the root change holds without a creator is in by the seats. A user counts at a statement if a - `create` or `vouch` for it counts whose signer counts there by a line that - doesn't pass through the user (so this ends), and the statement is within what - every `unvouch` of that one leaves; what is the seats' is taken back once every - root unvouched it. A statement counts if its user counts at it (a proposal and a - vote: always, for a voter); its key was the user's (added by statements that - count, up to its creation, or given by a decision); it is within every cut set - for that key (by a `retire` that counts, or a decision); a node carrying for the - user committed it (any node, for what any node commits), within that node's cut - if it has one; and it isn't past its limit (Users), by the limit that holds. A - `retire`, a stop and an `unvouch` are never outside a cut they set themselves, - nor left out with their carrier. Bans cut the same way, for those who follow - their signers. A user is **out** where no `create` or `vouch` for it counts any - more, or where it gave itself up. It is **gone** once seen out for `gone`, or - where a decision freed its name; and gone it stays, whatever is vouched or cut - off after. + `create` or `vouch` for it counts whose signer counts there by a line that doesn't + pass through the user (so this ends), and the statement is within what every + `unvouch` of that one leaves; what is the seats' is taken back once every root + unvouched it. A statement counts if its user counts at it (a proposal and a vote: + always, for a voter); its key was the user's (added by statements that count, up to + its creation, or given by a decision); it is within every cut set for that key (by + a `retire` that counts, or a decision); a node carrying for the user committed it + (any node, for what any node commits), within that node's cut if it has one; and it + isn't past its limit (Users), by the limit that holds. A `retire`, a stop and an + `unvouch` are never outside a cut they set themselves, nor left out with their + carrier. A user is **out** where no `create` or `vouch` for it counts any more, or + where it gave itself up. It is **gone** once seen out for `gone`, or where a + decision freed its name; and gone it stays, whatever is vouched or cut off after. 3. **Users' names.** A creation stands while it counts, isn't released, its user isn't gone, and a rule of the kind `user` lets its signer. Of the creations of a name that stand: the one that remains (Two claims) has the name, or has it wait while @@ -1396,9 +1390,10 @@ takes along those of the nodes that carry for a user it holds. and use the node's admin endpoints. The registry gives nobody anything on another party's node: a name of the node's own is the node's, whoever has that name in the registry. -* **Logging in by a key of the registry** works on a node for the users it carries - for, and for those its operator names besides. (Today a user with keys in the - registry logs in on any node *(docs)*.) +* **Whom a node lets in**, and what it lets them do, is its operator's. Having keys + in the registry gives a user nothing on anyone's node by itself. (Today a user + with keys in the registry logs in on any node *(docs)*.) What a user may write is + in its signature, whatever node it reaches. * **Tokens** are taken only from the node itself and from the nodes its operator names: its party's others. (Today every node takes a token any member signed *(docs)*: a party's node could let itself in anywhere.) Ended sessions are each @@ -1421,7 +1416,7 @@ at the change's dependencies alone. **Promise 2.** Whether a change is valid depends on the change and its history; its hash covers both. So honest nodes agree on every change, hold the same valid changes once each has what the other has, and Automerge gives the same document for the same -changes. Resolving is a function of the changes and the follows. Everything it reads +changes. Resolving is a function of the changes. Everything it reads is fixed by hashes: a statement's place is what it says it saw, a witness's word is its change's history, and a proposal is decided by its records' histories. A node's clock, and the order things reached it in, enter only into what its own node writes @@ -1433,7 +1428,7 @@ the document. What must hold for this, and doesn't everywhere today: node doesn't know; * a batch judged at heads that differ from a change's dependencies only where nothing the rules read changed in between: what screening takes as read by rules *(checked: - `screen::relevant` lists members, users, remakes, votes, access and bans)* must + `screen::relevant` lists members, users, remakes, votes, access and node bans)* must have the registers of users and claims, the decisions and what is uncovered; * nothing a node keeps a bounded number of decides validity: a change pushed out of the waiting ones comes again *(checked: `MAX_WAITING`)*; @@ -1721,7 +1716,7 @@ the party. In continuum, as rules every node judges by and data that parametrizes them: users by statements (creating, vouching and unvouching, lines, keys, cuts, nodes that carry), the namespace rule, claims by kind with their rules and limits, late, contested, -settled and final, bans, lengths of time read from the stamps, decisions by the +settled and final, lengths of time read from the stamps, decisions by the voters (the numbers, the policy, a user's first keys, names), remakes that every node builds and that name the voters and the roots, going apart and refusing a decision, resolving and its API, the drop an operator asks for. All of it is @@ -1752,8 +1747,7 @@ too. [`trust.md`](trust.md), [`access.md`](access.md), [`remakes.md`](remakes.md the glossary get the federated case: party, statement, in sight of, line, root, the seats', voter, claim, cut, late, giving way, contested, settled, final, out, gone, uncovered, seen for, taking a proposal up, a decision that holds, what hangs, carried -over, refusing a decision, bounds, the numbers, and a ban of a user beside a ban of a -node. +over, refusing a decision, bounds, the numbers. ## Continuum changing under a swarm @@ -1837,11 +1831,11 @@ Statements and users: | 9 | Creates a name in sight of its creation | Refuse | 4 | unit: `a_name_created_once` | | 10 | Creates a name another has, saying it saw nothing of it | Hold both; late once a root saw the first. Before: contested, or the first is late where a root's node got the other first | 4, 5 | unit: `a_backdated_creation_is_late` | | 11 | Gets a user's name contested to free its names | Its claims stand without the name | 5 | unit: `claims_stand_without_the_name` | -| 12 | Creates many users, each claiming many names (sybils); creates them out of each other's sight to pass the limit | Refuse past the limits in sight; out of sight, those past them don't count. A limit bounds how many each user brings in itself, not how many come in below it: each shows below its creator, for all to see, to ban, and to go with it when it is unvouched | 6 | unit: `limits_on_creating`, `past_a_limit_out_of_sight` | +| 12 | Creates many users, each claiming many names (sybils); creates them out of each other's sight to pass the limit | Refuse past the limits in sight; out of sight, those past them don't count. A limit bounds how many each user brings in itself, not how many come in below it: each shows below its creator, for all to see, and goes with it when it is unvouched | 6 | unit: `limits_on_creating`, `past_a_limit_out_of_sight` | | 13 | Adds keys, nodes or statements without end; signs and gives up without end (vouch and unvouch, claim and release, key and retire) | Refuse past the limits. What is given up counts toward none: it is taken no faster than a budget per party, and a remake leaves it out | 6 | unit: `limits_on_a_register`; sim: `a_party_past_its_budget_waits` | | 14 | Signs more than its limit out of each other's sight; another claims a name that so doesn't count; then gives the earlier ones up | What comes to count later than it was signed gives way to what was claimed in sight of it meanwhile | 5 | unit: `counting_late_gives_way` | | 15 | With a stolen key, signs statements that come before its user's own (keys, creations, claims), to push those past their limits | Until the key is cut off they do. What a cut leaves out comes before nothing: the user's own count again, and what was claimed in sight of them meanwhile gives way where a root's node had seen them hold | 3 | unit: `cut_off_comes_before_nothing` | -| 16 | Names another party's node as one that carries for it; offers that node a token of its own | A node carries only once it committed the statement naming it; a token is taken from nodes the operator named | 3 | unit: `a_node_carries_by_its_own_word`, `a_token_of_ones_party` | +| 16 | Names another party's node as one that carries for it; offers that node a token of its own | A node carries only once it committed the statement naming it; an honest node takes tokens only from nodes its operator named | 3 | unit: `a_node_carries_by_its_own_word`, `a_token_of_ones_party` | Unvouching: @@ -1945,7 +1939,7 @@ Decisions and remakes: | 92 | A node back after several remakes offers what its user signed epochs ago | Refuse: an envelope is taken in its epoch and the next. Quarantined, for the user to sign again | 3 | unit: `carried_over_one_epoch_only` | | 93 | A version builds another snapshot from a remake's base | Its node records another ID. The remake is decided for the ID two thirds got; the node stays, and says so | 7 | sim: `a_remake_by_its_result` | | 94 | A remake names its proposer the only root, or leaves a root out; the root left out signs on as one | The voters see whom a remake names before they vote for it. A root is one in the epoch that names it: what it signs after is an ordinary user's, and it is out unless someone vouches for it | 7 | unit: `roots_are_the_remakes`, `a_root_for_its_epoch` | -| 95 | Two thirds of the voters turn on the rest | They remake, name the roots and who votes, set any number (a share of the voters that lets one decide for all), change the policy, give a user's first keys to another, deal with the names of a user that is out, and say whose a contested name is: a name taken, in the open. They forge no signature and move nobody to other rules; the rest ban, refuse, or fork | not promised | argued (Going apart, Refusing a decision) | +| 95 | Two thirds of the voters turn on the rest | They remake, name the roots and who votes, set any number (a share of the voters that lets one decide for all), change the policy, give a user's first keys to another, deal with the names of a user that is out, and say whose a contested name is: a name taken, in the open. They forge no signature and move nobody to other rules; the rest refuse, or fork | not promised | argued (Going apart, Refusing a decision) | | 96 | Offers a statement signed on the other side of a fork | Refuse: it names its epoch | 3 | unit: `signed_for_its_user_id_and_epoch` | | 97 | A fork naming its proposer the only voter and root | A node follows only by its operator's word, which names the proposal; what that says shows | 7 | sim: `a_fork_by_choice` | | 98 | A decision breaks a node's bounds: the voters let one of them decide for all | The node refuses it and moves to the epoch built without it, the same for every node that refuses, with what it held: they go on together | 7 | unit: `bounds_on_the_numbers`; sim: `those_who_refuse_meet` | @@ -1961,7 +1955,7 @@ Nodes and syncing: | 103 | Places its nodes around a victim by choosing their keys | The victim's node keeps its seeds and its user's other nodes as neighbours; a claim not settled for long shows. It costs time, not names | 5, 6 | sim: `around_a_victim` | | 104 | Hands a joining node another root, or changes from before the policy | Refuse the handshake; there is no before | 1 | sim: `a_joiner_takes_its_root_only` | | 105 | Signs a token for any user with its node's key | Taken only by a node whose operator named the signing node | 3 | unit: `a_token_of_ones_party` | -| 106 | Logs in on another party's node with a key of the registry; has a name in the registry that the node's own users have | A node lets in by key the users it carries for and those its operator names; its own names are its own | 3 | unit: `login_by_key_is_the_operators` | +| 106 | Logs in on another party's node with a key of the registry; has a name in the registry that the node's own users have | Keys in the registry give nothing on anyone's node by themselves: whom a node lets in is its operator's, and what a user may write is in its signature | 3 | unit: `registry_keys_open_no_node` | | 107 | Lies in its member entry (ready, reached, stable); publishes a short window there to make every node stamp hourly; writes an entry of any size | Sync and trees bend; nothing gets in that way. How often nodes stamp is the policy's; an entry has a shape and a size, or the change is refused | 6 | unit: `an_entry_has_a_shape`, `stamps_by_the_policy`; argued (Reaching the others) | | 108 | Sends envelopes that don't check, without end | Refuse each (a signature costs about 30 µs to check *(docs)*); the node is refused as a whole after the first of its own | 6 | sim: `a_refused_node_costs_little` | | 109 | Writes its own member entry without end; fills the waiting changes; sends changes that say they saw little, each to be judged far back | Take them no faster than a budget per party: put off, never refused; a share of the waiting each | 6 | sim: `a_party_past_its_budget_waits` | @@ -1977,11 +1971,8 @@ Rules, and the swarm as it is: | 114 | A rule differs between versions (a bug) | Each side refuses what the other takes, or their stamps name two digests for the same changes: each logs and shows it. A node that finds itself apart from a third of the voters' nodes at its first start with a version writes nothing. One side upgrades and drops | not promised | sim: `a_side_drops_and_comes_back`, `two_digests_one_history`; unit: `a_node_checks_itself` | | 115 | Stamps a wrong digest, to keep the nodes that upgrade from writing | A node stops only where it differs from the nodes of a third of the voters; from fewer it shows it and goes on | 6 | unit: `one_wrong_digest_stops_nobody` | | 116 | A policy version a node doesn't know: in the root, or decided | It doesn't sync, and takes no such proposal up: a policy is decided only with two thirds of the voters' nodes knowing it | 1 | unit: `no_sync_under_an_unknown_policy`, `an_unknown_policy_isnt_taken_up` | -| 117 | A root that lies and isn't left out; a user nobody unvouches | The parties ban it from a cut on and read on without it | not promised | unit: `a_ban_for_those_who_follow` | -| 118 | A root bans the other roots, to decide alone what readers that follow the roots see | A node that follows several takes a ban only where most of them state it | not promised | unit: `a_ban_by_most_of_those_followed` | -| 119 | A banned user's name claimed by one who bans it | The node refuses its own user's write: the others would | 1 | unit: `no_write_by_ones_bans_alone` | -| 120 | A partition, for any length of time | A side decides only with nodes of two thirds of all the voters on it. Where a third of them have nodes and votes on both sides, both may: every node then acts on the higher number. A remake is taken up on one side only by a voter's honest nodes, which record one base | 7 | sim: `one_side_decides`; unit: `the_last_holds` | -| 121 | None: a swarm that isn't federated | Everything as today | Optional | the existing tests, untouched; `bench_screening` | +| 117 | A partition, for any length of time | A side decides only with nodes of two thirds of all the voters on it. Where a third of them have nodes and votes on both sides, both may: every node then acts on the higher number. A remake is taken up on one side only by a voter's honest nodes, which record one base | 7 | sim: `one_side_decides`; unit: `the_last_holds` | +| 118 | None: a swarm that isn't federated | Everything as today | Optional | the existing tests, untouched; `bench_screening` | ## The registry on it ``` @@ -2030,16 +2021,15 @@ repository; a decision changes them after. operator trusts (its own) and writes the tree the consumers read (`<user>/hosts/<host>/retiolum/{aliases,ip4,ip6,ed25519.key}`), leaving out what doesn't count and any address or name its host's user doesn't hold. Run on each -change of the document (the store's stream), it replaces the merge button. Whoever -writes out follows someone's bans (its own user's, unless it says otherwise), so two -parties that ban differently write different files where a name is contested. -Readers that are to see the same follow the same users: the roots, for the files -the network at large reads. +change of the document (the store's stream), it replaces the merge button. An +operator that leaves users out when it reads writes other files than one that +doesn't, where a name is contested: what the network at large reads is whose node +it trusts for that. ## Stages Each leaves the system working, and is a few patches with its tests, which leave -their vectors. At every stage the existing tests pass untouched (121). +their vectors. At every stage the existing tests pass untouched (118). 1. **A federated swarm's frame.** `--genesis-policy` (a file, written into the genesis change with the roots, the voters and the users it starts with); a federated node @@ -2047,7 +2037,7 @@ their vectors. At every stage the existing tests pass untouched (121). takes tokens and logins by key as its operator says, keeps ended sessions to itself, stamps as the policy says, and writes a member entry of the policy's shape and size. What the genesis change sets for the swarm as a whole is read from the - policy. Tests: 104 to 107, 116, 121, and the policy's existing tests under a policy + policy. Tests: 104 to 107, 116, 118, and the policy's existing tests under a policy from the root. 2. **Statements.** The users' registers (`create`, `key`, `node`, `vouch`, `release`); the user ID, the epoch and what its signer saw in an envelope; nodes carrying for @@ -2080,23 +2070,22 @@ their vectors. At every stage the existing tests pass untouched (121). 8. **Coming back.** The drop an operator asks for, a forked actor proven and shown with what the roots' nodes hold, the budget and the share per party, the writers it counts, a node keeping its writer over a clean stop. Tests: 101, 108 to 112. -9. **Bans** for those who follow. Tests: 117 to 119. -10. **The registry.** Import, export, and a federated swarm of the simulations with - the registry's kinds and a few hundred hosts. From here it can be tried: users, - hosts, names, a root that settles, names that become final. It isn't to be relied - on yet. The stages after change the rules, and until a policy changes by a - decision a rule changes only by every party upgrading at once: a swarm started - here is started anew after the last stage, by an import of what it holds. -11. **Decisions.** `propose` and `vote`, signed by the client and taken from any node, +9. **The registry.** Import, export, and a federated swarm of the simulations with the + registry's kinds and a few hundred hosts. From here it can be tried: users, hosts, + names, a root that settles, names that become final. It isn't to be relied on yet. + The stages after change the rules, and until a policy changes by a decision a rule + changes only by every party upgrading at once: a swarm started here is started anew + after the last stage, by an import of what it holds. +10. **Decisions.** `propose` and `vote`, signed by the client and taken from any node, the nodes' records and how they are judged, taking up, decided, the decision that holds, what hangs; `GET /registry/decisions`. What is decided: a number, a user's first keys, the names of a user that is out, whose a contested name is, a name the rules leave to the voters. The simulations start from a root change naming several - voters, as a remake's does. Tests: 18, 56, 60, 63 to 78, 120. -12. **Versions.** The digest with every stamp, a node checking itself before it + voters, as a remake's does. Tests: 18, 56, 60, 63 to 78, 117. +11. **Versions.** The digest with every stamp, a node checking itself before it writes; for every swarm, a node that speaks the wire version before its own, and a handshake that says which epochs its node keeps. Tests: 114, 115. -13. **Remakes.** The proposal with its list of voters, its roots and its coordinator; +12. **Remakes.** The proposal with its list of voters, its roots and its coordinator; the base, one an epoch, taking a remake up by its result, the snapshot every node builds, what it leaves out and what can't be written again; carrying over, by every node, with what it held of what it carries; a retirement's list as its cut; @@ -2104,10 +2093,10 @@ their vectors. At every stage the existing tests pass untouched (121). keeping the epochs it left on disk, peers answering for them and saying which; a node walking them, or rejoining by an ID its operator gave, and by none that peers advertise. Tests: 61, 62, 81 to 94. -14. **The policy by a decision.** The policy as a matter, a node that doesn't know it, +13. **The policy by a decision.** The policy as a matter, a node that doesn't know it, what it no longer covers: shown aside, taken away by its user only, dropped after a time, moved at a remake. Tests: 79, 80, 116. -15. **Going apart, and refusing.** A fork followed by an operator's word, with who +14. **Going apart, and refusing.** A fork followed by an operator's word, with who votes and who the roots are on its side. Refusing a decision: a node's bounds, the epoch without the decision, what a node takes along. Tests: 95 to 99. From here it can be relied on: the rules change by decisions. |
