aboutsummaryrefslogtreecommitdiffstats
path: root/docs
Commit message (Collapse)AuthorAgeFilesLines
* docs/federation: the design on the storetv29 hours1-635/+409
| | | | | | | | | | | | | | | | | | | | The federation is the store's fold. What a party signs is an event: a JCS object naming its dependencies, signed with an SSH signature by one of its party's keys, or by nobody for a federation's root, a fork's and a version. An event names no swarm, no version and no place in the document: its history says which store it is in and which version it is written under. A place is a path a rule matches, its value the latest write its party signed there that counts: one that no other counting write there has in its history, and of several the one with the lowest ID. Key sets and node lists are read the same way. A vote, proposal, key set and node list is an event of its own kind, a passed proposal takes effect by a version event, and a node takes a version only where it changes the one it reads, as before. A fork is a store whose root builds on the heads it forks at, carrying their history, so that any node checks it from its events alone. What carries the store, its document and its remakes, the federation leaves to `docs/store.md`, with the promises and attacks about them; the attacks left are numbered anew.
* docs/store: a store of events, generic over its foldtv29 hours1-0/+306
| | | | | | | | | | | | | | | | | | | A set of events that only grows, each named by the SHA-256 of its bytes and naming those it builds on, judged at that history so that every node judges it alike, and read together as one state. What the events are, how one is judged and what they read as is a fold's, a trait the federation is the first to implement. Its first home is a swarm's Automerge document: each event is bytes at `_continuum/events/<ID>`, a change writes events and continuum's protocol data only, and a node puts again every event it doesn't refuse of a change it refuses or drops, so that which change carries an event changes nothing. A compaction's snapshot holds the events at its base, and every event beyond it is put again: remakes, rejoins and a writer's two changes of one number change no event a node holds, and the fold never sees them. It says what is promised, a node's own refusals and drops, forks carrying their root's history, members by the fold, where Automerge sets limits, its attacks, and what its tests check. Nothing of it is built; all of it is to be behind the `federation` feature.
* federation: "Why it holds" on a version written againfederation-2tv31 hours1-10/+10
| | | | | | "Why it holds" said a node takes a version only where it changes the one the node reads, where the design has it take one it took, written again, too.
* federation: what a snapshot leaves out, said as it now istv31 hours1-4/+6
| | | | | | | | What counts no more stayed, the text said, until a snapshot or a fork's genesis left it out where it is or names a version before the current one. But each holds a place's value alone: an envelope that isn't it, behind another or a dropped key's, goes whatever version it names, and a key added back brings back what it signed within the epoch only.
* federation: every party a node list in every version, the example tootv31 hours1-6/+7
| | | | | | | | Since a party new in a version has its list named anew there, every party has a list in every version from the one that let it in; the field said lists were for the parties a version named one for. The example gave makefu, its keys named anew at 7, none, and was no version. The field says every party's, and the example gives makefu an empty list since 7.
* federation: a decision nobody follows is none of twotv31 hours1-5/+7
| | | | | | | | | A node follows no remake whose coordinator its party doesn't list, but a node holding two decisions for its epoch followed neither, whatever they were: a node taken off its list, by deciding a remake nobody follows, still kept every node holding its decision from following an honest remake of that epoch, until operators named one. A decision whose coordinator isn't listed is none of the two.
* federation: a dropped version refused however it is writtentv31 hours1-5/+5
| | | | | | | | | A node refused the changes its operator had it drop. But any member writes a version once it passed, and a change writing the dropped version anew, by a lagging node by chance or a listed adversary at will, was none of those: the node took it, as it changes the version the node reads, and a node its operator was moving across a remake stayed. The node refuses any change writing a version among those it dropped.
* federation: no bound on the writers a party's nodes starttv31 hours1-25/+22
| | | | | | | | | | | | | | The bound was judged at a change's history, as any rule is, so it counted only the writers in that history: writers started side by side, each at a history holding none of the others, were each within it, and a party flooding on purpose passed it as often as it liked. Counted for a party, it let one node gone wrong use up the room of all its party's nodes for the rest of the epoch. It goes. A party whose nodes start writers without end runs the others out of memory: denial of service, which breaks no promise. Its writers name its node, and the node's entry its party; a remake leaves an epoch's writers behind, and the others fork without the party.
* federation: what an end-to-end read found at oddstv32 hours1-26/+28
| | | | | | | | | | | | | | | | | | | | | Read whole after the last series of changes, the design said a few things that no longer fit what it says elsewhere: * the example's version 7 named lass's keys anew at 4 but gave lass no node list, where a party new in a version has its list named anew; * a remake reaches no node that can't build it, nor one that isn't to follow it (not a member at the base, its coordinator unlisted); * the clause on whose word follows a decision sat after a colon meant for the abort; * what a node taken off its list could commit before a base ends with the remake only where the base holds that list; * a remake racing a listing leaves behind the nodes listed since the base, not "the nodes that took it"; * "Why it holds" now names the coordinator's listing; * attack 29: a node that lacks the base syncs it where a peer keeps it; * forks come at stage 4, so before it no swarm starts afresh by one; * a party drops a stolen key of its set itself; only one its version names takes a version.
* federation: wordings left from the last changestv33 hours1-20/+21
| | | | | | | | | | A version's `since`, where it doesn't name a party's keys or list anew, is the `since` the version it changes gives the party, not that version's number. A version written again is one a node took, and every node takes it however often it is written. A forked writer's nodes are apart until operators have one side drop what it took, or a fork. And a fork's genesis leaves out continuum's own data, earlier epochs' metadata among it, which a second clause said again.
* federation: a party new in a version, its node list named anewtv33 hours1-1/+4
| | | | | | | | | A list had a `since` only for a party a version named one for. A party taken out and let in again within an epoch had none unless the version named it a list, so the list it left, signed with the keys it had then, counted again at once, while its key set, its keys named anew, didn't. A party new in a version has its list named anew there, empty where the version gives it no nodes.
* federation: the writers a party's nodes start, boundedtv33 hours1-6/+8
| | | | | | | | | The bound on writers was a node's, and a party lists the nodes it likes, a new list one envelope: the flood the bound was for cost a party a list now and then. The bound is a party's: the writers its nodes start in an epoch together, by the party each node's entry names, judged at a change's history. Its figure leaves room for the writer an honest node starts each time it starts, rejoins or drops, until a remake.
* federation: no remake followed whose coordinator its party no longer liststv33 hours1-6/+9
| | | | | | | | | | | | | A node taken off its party's list is a member at a history from before: a remake's record, proposal and decision it writes there are taken, and every node listed at its base follows, the snapshot listing the node again until the list that took it off is replayed. "The next remake's base" could be its own. A node follows a remake only where the coordinator's party lists the coordinator, as the node reads it when it switches; and what a node taken off its list commits from a history before ends with a remake whose base holds that list.
* federation: acks bind nobody in a federated swarmtv33 hours1-4/+6
| | | | | | | | | | | | | Continuum lets a member ack another remake of its epoch only once the first is aborted, and in a federated swarm only the coordinator aborts: a coordinator gone after proposing stalled every remake of its epoch. Read the other way, as a remake left undecided binds nobody, members moved on, and a coordinator back late decided beside the remake they moved to: two decisions, from honest nodes alone. Acks bind nobody: a member may ack another remake without the first aborted, and an honest coordinator decides only while the acks it counts are still for its remake.
* federation: a snapshot keeps each place's value as the federation reads ittv33 hours1-34/+36
| | | | | | | | | | A place's value is read among the envelopes a key their party holds signed, but a remake's snapshot, a fork's genesis and the replay held what the old document "read as", which continuum's merged view has as the first of all the envelopes there, by `seq`: a builder reusing it would keep a dropped key's envelope ahead of the party's, and nothing at the place would count in the new epoch. Each holds, and replays to, the place's value as the federation reads it.
* federation: what an operator had its node drop stays droppedtv33 hours1-4/+7
| | | | | | | | | | | | | | An operator may have its node drop what it took, and nothing said the node refuses it afterwards: a peer that still holds it sends it again, and the node, holding the votes that passed a dropped version, writes it again itself, as a node writes any version it holds passed. So the version a node left behind by a remake dropped came back before it switched, and either side of keys that voted twice took again what it dropped until it held the other side. In that epoch a node refuses the changes its operator had it drop, from whoever brings them, and writes no version among them again, until its operator says otherwise.
* federation: two `true`s voting twice only where neither proposal is deadtv33 hours1-11/+14
| | | | | | | | | | | | | | | A party's `true` on two proposals of one version was voting twice where both passed, or neither was dead by all the votes. But a party's `true` and `false` on one proposal both count, so one proposal can be passed and dead at once: another party's late `true` beside its `false` made every party that went on to the second proposal, once the first was dead, look as if it had voted twice. Two `true`s are voting twice only where neither proposal is dead by all the votes. A death is never taken back, so an honest party's first proposal is always dead by all of them; and where two versions changing one were written, the party whose `true` and `false` made a proposal passed and dead is named. "Why it holds" says the same.
* federation: what acks are for in a federated swarmtv39 hours1-3/+5
| | | | | | | Acks stay continuum's, by node, but in a federated swarm a node follows a decision it can build without counting them, so what they decided was nobody's to say. They tell an honest coordinator when to commit, so that fewer nodes are away; they are no safeguard.
* federation: a node a remake left behind for a version, moved by its operatortv39 hours1-4/+7
| | | | | | | | A remake that races a version leaves the nodes that took it in the old epoch. Its operator moves such a node without a fork or an empty document: it has the node drop the version it took, the base then holds the version it reads, it switches, and the new epoch writes the version again from the votes replayed, as any node writes one it holds passed.
* federation: forks before remakestv39 hours1-7/+8
| | | | | | | | | Forks are what any group carries on by, and promise 3 rests on them; remakes are there only for Automerge's sake. Forks come at stage 4 and remakes at stage 5: until then a federated swarm that grows too large starts afresh by a fork whose version names the same parties, keys and rules. And a writer forked splits the nodes for good only until stage 2, where an operator may have its node drop what it took.
* federation: what a version names anew, by a number, nothing unsignedtv39 hours1-99/+99
| | | | | | | | | | | | | | | | | | A version setting a party's keys or node list had the change writing it write an envelope without a signature at the party's place, `prev` empty and `seq` 0, and only that change, so that it was ahead of every set before it: a kind of envelope of its own, a rule on who writes it, the same written again with the version, and a genesis and a fork writing them too. Each version gives, for each party's keys and node list, the number of the version that named them anew (`since`): its own where it does, else that of the version it changes. A party's keys are those of its set where the set names a version numbered at least that; otherwise those the version names; its node list the same. Nothing is written for it, the document holds no envelope without a signature, and what a key an earlier version named writes at a history from before still counts no more.
* federation: an operator may have its node drop what it tooktv39 hours1-6/+18
| | | | | | | | | | | Where keys voted twice, or a writer forked, each node kept what it took, and the sides came together only by a fork, a node with an empty document, or its peers' word. An operator may have its node drop a version, or any change, with everything built on it, as continuum drops a change its node took and the rules refuse (`drop_taken`), and take what the others hold: no peer's word moves a node, its operator's does. So either side may join the other without what parts them, as the design request asked, without a fork.
* federation: wordings that said more than the design doestv39 hours1-15/+17
| | | | | | | | | | | | Which federation a swarm follows is in each version, not in its policy's place; a fork's first version changes the one current at its heads, not `null`; a place given back shows what its party signed before only where nothing replaced it since; a remake's snapshot is a function of its base and its record, so two remakes at one base are two epochs; honest nodes agree once they sync but where keys voted twice, a coordinator decided two remakes, or a writer forked; and what a node taken off its list commits from a history before ends with the next remake's base, as no later version orders it.
* federation: the writers a node starts, boundedtv39 hours1-4/+10
| | | | | | | | | Every writer costs every node memory for as long as the epoch lasts, and nothing bounded the writers a node starts: one listed node starting one with every change runs every other out of memory before a remake could be built, which the design called slow, not wrong. A federated swarm bounds the writers a node starts in an epoch, judged at a change's history as any rule is: a rule, and stage 1's.
* federation: a party that voted twice read from its votes, by a tooltv39 hours1-9/+11
| | | | | | | | | | | A node reported a party that voted twice, judging each copy of its votes by the history it was taken at, so that a vote committed again elsewhere framed nobody; and the next remake left those histories out. The votes alone tell it: a `true` and a `false` on one proposal, or a `true` on two proposals of one version where both passed or neither is dead by all the votes cast, as an honest party backs another only once the first is dead. A tool over the votes the parties' clients keep reports it, later too; a node reports the versions it refused.
* federation: a node takes no token another node issuedtv39 hours1-23/+22
| | | | | | | | | | | A node took tokens from the nodes its party lists, and without a user registry every user it lets in may do everything. A party's list is written by a key its version names, or set by a version: so two thirds of the parties, or a thief of that key, could list a node of their own as the party's, issue a token under any name there, and have the party's own nodes take it, against "the design rules nothing about what happens on a party's own nodes". A node takes only its own tokens; a party logs in to each of its nodes.
* federation: of two versions that come together, the first judgedtv39 hours1-4/+4
| | | | | | | | A node holding two versions that change the one it reads, having taken neither, took neither until its operator named one. But where one comes first it is taken anyway, and two come together only by how a sync message was cut: the state, and the endpoint naming one, guarded nothing. A node takes the first it judges.
* federation: what a replay refused, tried again; a client votes by its owntv39 hours1-4/+8
| | | | | | | | | | | A replay puts changes neither of which saw the other by their clocks. A party's `true` committed again at a history before the nays that freed it, its clock set between, came before those nays in the replay and was refused, though the old epoch took it: a proposal that passed there might not pass in the new one, and a party not finding its vote might vote again. What the new epoch refuses is tried again once the rest is replayed, and a party's client keeps what its party voted and votes by that, never by what a node shows.
* federation: a node shows whether a proposal is a versiontv39 hours1-1/+4
| | | | | | | | | | A proposal is taken whatever its text, and asked whether it is a version only where it is written as one. One that isn't is voted on, never passes, and dies only by nays: two thirds backing it bind the federation to its version for good, and a client reading JSON otherwise than the nodes backs what no node writes. A node shows whether a proposal is a version by the federation it knows, and a party's client backs none that isn't.
* federation: what a node's API users may have it committv39 hours1-0/+3
| | | | | | | | Without a user registry, every user a node lets in may do everything, and `--protocol-writers` say who writes protocol data; what of that held in a federated swarm the design didn't say. Whoever a node lets in may have it commit what the rules take, envelopes and the node's own protocol data; `--protocol-writers` names nobody.
* federation: sizes among what the federation's number namestv39 hours1-8/+11
| | | | | | | | | Nothing bounded a version, a key set, a node list, a path or a value: a version larger than a sync message carries would be written where it passed and reach nobody, and nodes built with different bounds would take different changes. The sizes each may have are the federation's number's, each within what a sync message carries, and stage 1 sets them.
* federation: a member at a remake's base is a node its party lists theretv39 hours1-9/+10
| | | | | | A node follows a remake only where it is a member at the base: listed there, or listed and registered, the design didn't say. Listed: a node its party listed registers in the new epoch as it would have in the old.
* federation: a passed version written as soon as a node holds it passedtv39 hours1-5/+6
| | | | | | | | Any member wrote a passed version; when, and which, the design didn't say: every node that sees it passed, the one that took the last vote, or one after a wait. A node writes it as soon as it holds it passed; the same version written by several is one, as a node takes a version it took written again.
* federation: a federation's genesis built from its first versiontv39 hours1-18/+24
| | | | | | | | | | | | A federation's genesis change, judged by none, was its founding node's: what else it held (values at places, votes) nobody checked, and the swarm's name was the one its node drew or remembered, so two federations started under one name took each other's envelopes. It is built byte for byte from the first version alone, as a fork's genesis is from its version and heads, and holds the policy, the swarm's name, the version and what it sets, nothing else; the swarm is named by the version's hash, and a node joining builds the genesis and checks it. The genesis writes no topology: a federated swarm runs continuum's own.
* federation: what a fork's genesis leaves out, by which versiontv39 hours1-8/+9
| | | | | | | | | | A fork's genesis left out what a snapshot does, the federation's versions, member entries and the swarm's name. It didn't say what of continuum's other data it holds (remake records, acks, earlier epochs' metadata), nor whether what counts no more is read by the fork's first version or the one current at its heads: two founders deciding apart build two swarms where one is meant. It holds none of continuum's own data, and reads what counts no more by the version current at its heads.
* federation: a `prev` names what the place holds, whoever signed ittv39 hours1-1/+4
| | | | | | | | A party writing first where another's envelope is (a place given to it, an envelope a dropped key wrote) could name that one as replaced, `seq` one more, as judging at a change's history needs, or start anew; two builders deciding apart would refuse each other's envelopes. It names that one.
* federation: a map made only on the way to what a change writestv39 hours1-11/+14
| | | | | | | | | | | A change wrote nothing where rules say who writes but `@` keys and the maps on the way to them, never deleting or replacing one. It didn't say that a map is made only on the way to an `@` key the same change writes: one builder would take any member's maps in any party's namespace, left empty for good, another wouldn't. Nor that a map is made only where none is: a map made where one is, naming it as replaced, hides what it held, votes under `_continuum/federation` among them. Both are said, for the federation's own paths too.
* federation: `{party}` matches only a party's nametv39 hours1-2/+4
| | | | | | | | Where a rule's `{party}` segment met a segment naming no party, one builder would match it with a writer that is nobody, another wouldn't match and let a later rule decide, and the two would judge a write at `names/r/foo` apart where a `names/r/*` rule follows. It doesn't match, which is the reading the wiki example needs.
* federation: a party's `true` and `false` on one proposal both counttv39 hours1-1/+4
| | | | | | | | | Where a party's `true` and `false` on one proposal are both in one history, the design didn't say whether it voted yes, no, both, or what the place read as; one builder's node would take a version, or another party's next `true`, where another builder's refused it. Both count: then a history that holds more votes never takes back a pass or a death.
* federation: two decisions for one epoch, and an abort, its coordinator'stv39 hours1-8/+17
| | | | | | | | | | | | | | | | A remake's decision was its coordinator's alone, but a member could abort a remake that expired, as each node's clock said: the one place the design waited on time. And a coordinator writing two decisions for one epoch, showing each to some nodes, left honest nodes in two epochs for good, as continuum's following of most peers, and rejoining sideways, are gone. The abort is the coordinator's too, and a remake left undecided binds nobody. A node holding two decisions for its epoch follows neither, says so, and leaves it to its operator; on its operator's word it builds the remake named of the epoch before its own, from the old document it keeps, and switches, what it wrote since replayed. Not promised and Attacks say so.
* federation: a place's value among the envelopes their party's keys signedtv39 hours1-16/+23
| | | | | | | | | | | | | | | | A place's value was the first of all the envelopes it held, by version, then `seq`, and it counted only while its key was its party's. So a key the party had dropped, by a member committing at a history from before the drop, wrote ahead of the party's envelope, replacing it, with a higher `seq` each time the party wrote again: nothing at the place counted until a version named the party's keys anew. A place's value is the first of the envelopes there that a key their party holds signed; judging, and the envelope a `prev` names, go by all of them as before. And a party signs again what should stay after the set that drops a key, not only before: what the dropped key writes at a history from before can't name that as replaced, and counts no more, so it takes nothing out.
* federation: stage work for screening and a new node's partytv40 hours1-10/+13
| | | | | | | | Screening judges a batch at a frontier that every change touching what the rules read moves, or a later change of the batch is judged at heads it doesn't hold: stage 1 moves it for what the federation reads too. And a node syncs with members only, but is one only once its own entry names its party: stage 3 shows the party in the handshake before that.
* federation: no version replayed across a remaketv40 hours1-19/+25
| | | | | | | | | | | | | | A node switches only where the version it reads is written at the base. So a node that switches took no version written after it, and what it replays names the version current at the base, or one before: the replay of versions, each in one change with what it sets, after the votes that passed it and whatever names the version before it, was there for no node. It goes, and with it two `true`s cast at once, replayed one after the other, undoing a version that passed. The version a node reads is asked as it reads it when it switches: one it takes while it builds the snapshot leaves it where it is, as one taken before.
* federation: the old epoch synced with nodes still on ittv40 hours1-4/+9
| | | | | | | | | | | A node leaves its epoch only for one it built itself from a base it holds; but continuum stops syncing the old epoch once it switched, so a node away across a switch lacked some of the base and stayed until its operator moved it, on most remakes where nodes come and go. A node syncs the old document with nodes still on that epoch for as long as its own setting keeps it, and a node that lacks some of the base syncs it from them, each change judged there, and builds then.
* federation: a fork taken only on history a node holdstv40 hours1-14/+17
| | | | | | | | | | | | A node holding the old document left an epoch only for one it built itself, but took a fork's heads' history, where it lacked some, on its peers' word: a founder could name heads holding a change it sent nobody, a version written without votes say, and the genesis would carry what that change set. A node holding the old document takes a fork only where it holds the heads' history, syncing what it lacks from the old swarm, each change judged there; otherwise it says it can't check and leaves it to its operator. Only a node with an empty document takes a fork on its peers' word, as it takes an epoch.
* federation: a snapshot leaves out the entries of nodes no longer listedtv40 hours1-4/+8
| | | | | | | | | | Nothing is deleted within an epoch, and a snapshot left out only what is or names a version before the current one, which no member entry does: the entry of every node its party stopped listing, every node reinstalled under a new ID among them, stayed for good. A snapshot leaves out the entry of a node its party doesn't list at the base; a node listed again registers again. A fork's genesis holds no member entries already.
* federation: a version refused for its side, its committer nottv40 hours1-4/+7
| | | | | | | | | | A node refuses a version that doesn't change the one it reads, valid at its history or not. Continuum refuses as a whole a member whose own change broke a rule, sending it nothing more; a version valid where it was written breaks none, and its committer, often an honest member on the other side of keys that voted twice, would stay cut off after the operators settled. It isn't refused as a whole, and the node reports it apart from changes against the rules.
* federation: a proposal refused where its text isn't its place's hashtv40 hours1-3/+5
| | | | | | | A proposal was taken whatever its text, yet named by the hash of its version: one builder took a proposal whose text hashes elsewhere, another refused it, and their nodes parted. It is refused: the hash asks nothing of what a version may say, so every node asks it alike.
* federation: a version a node took, written again, takentv40 hours1-5/+6
| | | | | | | | | | | A node took a version only where it changed the one it read, or was that one written again. A member that was away writes a passed version itself, at a history where the version before is current, and the others took the next version meanwhile: its change writes neither the version they read nor one changing it, so they refused it and everything the member built on it, an honest member split off. A node takes a version written again wherever it is one the node took.
* federation: versions a node takes, epochs it builds, values in `@`tv41 hours1-354/+408
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | What the design leaned on that didn't hold, and what it can do without: * A vote counts as cast wherever its version is current, so the keys an earlier version named could pass another proposal on it at a history from before the version that followed, raise its number alone, and be read by every node. A node takes a version only where it changes the one it reads; another it refuses, reports, and leaves to its operator. Two that change one are written only where keys voted twice: each node keeps the one it took, and the parties fork. The lower hash goes. * A node left its epoch on its peers' word (catching up), or for a remake at any base its coordinator named. It leaves an epoch only for a compaction it built itself, from a base it holds, a member there, the version it reads written there; the decision is the coordinator's alone, and how long the old document is kept the node's own setting. The check that a remake reads as the old document goes, with remakes of other kinds. * Housekeeping within an epoch shrank nothing (Automerge keeps every operation), and an emptied place read whatever anyone put back. Nothing is deleted in an epoch but by a party's own `null`; a snapshot and a fork's genesis leave out what counts no more and is or names a version before the current one. Rule 7, putting back and the replay's deletions go. * A key could hold an envelope and a map at once. A place's value is in its `@` key, which never holds a map, so no key is both; `**` stays. * A key set dropping the key that signed it counted no more by the rule for values. Sets are checked only where written, and signed, as node lists are, only by keys the version names, so a party revokes a key of its set by itself. What a version sets for a party (keys, and now node lists, as the first version and a fork's do, so that a group without listed nodes can fork) is one envelope, `prev` empty, `seq` 0. * The federation's envelope is `cv3.`, so that swarms that aren't federated read nothing new; neighbours are kept partly by party; the krebs users who will vote are the parties, the others in a group. * The share is two thirds, the field gone; `went/` goes. And what two builders would decide apart: a version's bytes its JCS encoding, validity asked where it is written as a version, the rule grammar's edges, keys holding `/`, the double-vote report against a vote committed again elsewhere, one list of the protocol data a federated swarm takes, the Automerge version a rule, releases working together, the swarm key, a yes that can't be taken back, what stage 1 covers and that its swarms are for tests.