Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
3 changes: 3 additions & 0 deletions docs/changelog/fix-left-writer-listing.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,3 @@
### Corrigido

- Os leitores voltam a aceitar o escritor de quem saiu de um grupo antes de o semeador guardá-lo (PR `fix/left-writer-listing`, #350): o semeador lista esse escritor, e também o liberado por um corte, pela última entrada ligada no grupo, e não mais pela entrada desligada, que os nós no app, na web e na CLI recusavam e contavam contra o semeador. Uma listagem já guardada com a entrada desligada se corrige no próximo escaneamento do diário. Só o semeador muda: os apps instalados continuam como estão. Verificação em `docs/verification/fix-left-writer-listing.md`.
4 changes: 2 additions & 2 deletions docs/protocol.md

Large diffs are not rendered by default.

60 changes: 60 additions & 0 deletions docs/verification/fix-left-writer-listing.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,60 @@
# Escritor de quem saiu, listado pela entrada ligada (branch fix/left-writer-listing)

Parte da #350. Correção do semeador que entrou na #713 (`feat/writer-slot-walk`, commit 8772d908).

## O problema

Desde a #713 o semeador guarda, marcado como `left`, um escritor contado cuja última entrada no diário está desligada, e um escritor liberado por um corte 0. Ele listava esse escritor com a seq da última entrada do diário (`liveGroupJoins` em `packages/core/lib/seeder.js`), que para quem saiu é a entrada desligada (`on: false`). Essa seq vai para a admissão (`admitted.json`, `groups[W].seq`) e para a página de escritores do grupo. Todo leitor confere a seq do item contra o bloco do diário e exige um `group-join` ligado que nomeie o escritor e o grupo: `joinVerdict` em `packages/core/lib/sync.js` e a conferência equivalente em `packages/web-member/lib/sync.js`. Com a entrada desligada, o leitor recusava o escritor como `unbound` e contava a listagem contra o semeador (`badHint`; com 32 listagens recusadas, ele deixa de usar aquele semeador). O leitor do serviço de conta (`apps/cli/lib/account/pages-groups.js`) lê os diários inteiros e não usa a seq do item, então não era afetado.

Acontecia quando o semeador guardava o escritor depois da saída: uma saída antes de o semeador ver o escritor (entrar e sair entre duas sincronizações, uma busca do escritor que demorou) ou um semeador novo que conhece o diário depois da saída. Um escritor já guardado antes da saída mantinha a seq da entrada ligada.

## O que mudou

Só o semeador (`packages/core/lib/seeder.js`); nenhum leitor muda.

- `groupWalkStep` guarda, na caminhada de cada grupo, a seq da entrada ligada mais nova de cada escritor que a caminhada conta ou liberou (`onSeq`). O mapa nunca passa dos limites da caminhada por grupo (8 vivos, 8 congelados, 16 liberados).
- `liveGroupJoins` lista o escritor que saiu, e o liberado, com essa seq. A caminhada só conta um escritor depois de uma entrada ligada, então ela sempre existe.
- `_reconcileGroups` passa a usar a seq da listagem também para um escritor que saiu: uma ligação guardada com a seq da entrada desligada (pela versão anterior a esta) se corrige no próximo escaneamento do diário, em memória, na página e em `admitted.json`. Uma ligação que o escaneamento não lista (o diário nomeou W em outro grupo, ou o grupo passou do limite de 64) continua com linha na página: ela recebe a entrada ligada mais nova de W naquele grupo pela caminhada, assim que o escaneamento a lê; até lá fica com a seq guardada. O resto fica como estava: a marca `left`, os limites por diário, `groupRefused` pela seq e a caminhada.
- Com a #717 (`fix/group-records-ignore-deletes`) já na `main`, uma entrada apagada que chega depois de o escaneamento passar por ela refaz a caminhada do grupo (`foldGroupRecord`), também pelo `groupWalkStep`. Assim `onSeq` acompanha: um escritor que saiu, cuja entrada ligada apagada chega atrasada, é listado por ela. Esse caminho não precisou de mudança no código, só de um teste.

Documentos: `docs/protocol.md` seção 10, "Seeder group admission" ("Scan") e "Data-dir files" (`groups` de `admitted.json`).

## Testes

Cada arquivo sozinho, a partir da raiz, com `VARANDA_TEST_CONCURRENCY=1 node <arquivo>`:

- `packages/core/test/seeder-groups-cuts.test.js`: 14/14, 296 asserções.
- Novo: "a stored binding the scan no longer lists gets its on join too, never an off one (#350)": a ligação de W em G guardada com a seq 2 (entrada desligada); o diário depois nomeia W em H, e o escaneamento lista W só em H. `_reconcileGroups` dá à ligação e à linha da página a seq 1 (a entrada ligada em G), marcada `left`.
- "liveGroupJoins: a counted writer whose join is off stays, left; an uncounted one does not (#350)": as duas expectativas que pediam a seq da entrada desligada (10 e 3) agora pedem a da entrada ligada (2 e 2).
- Novo: "liveGroupJoins: a left or released writer is listed by its newest on join for the group, never an off join (#350)": entrou duas vezes e saiu; liberado e depois saiu; entrada ligada em outro grupo antes; saiu, voltou e saiu de novo.
- Novo: "a writer that left before its admission is listed by its on join, and a binding stored with the off join heals at the next start (#350)": B entra com W e sai (uma saída em W e a entrada desligada) antes de o semeador ver W. O item da página e `admitted.json` trazem a seq 1 (entrada ligada) e `left: true`. Depois, com o semeador parado, `admitted.json` recebe a seq 2 (a entrada desligada, como a versão anterior gravava); no reinício o escaneamento devolve a seq 1 à página e ao arquivo, sem descartar W.
- `packages/core/test/sync-groups-7.test.js` (novo): 1/1, 12 asserções. Ponta a ponta com o nó core: Ana cria o grupo, Bia entra, publica e sai pelo `member.groupLeave` antes de sincronizar; depois do semeador, a sincronização de Ana busca o escritor de Bia sem nenhum `group-skipped` e lê a publicação de antes da saída.
- `packages/web-member/test/sync-groups-3.test.js` (novo): 1/1, 14 asserções. O mesmo com o nó do navegador (`ops.groupLeave`) e um terceiro membro lendo pelo semeador via WebSocket.
- `packages/core/test/seeder-delete.test.js`: novo "a deleted on join that arrives after the scan lists its left writer by that join (#350)": o diário entra com W (seq 1), sai (seq 2, entrada desligada) e apaga a entrada (seq 3). O escaneamento lê a seq 2 e passa pela 1 como buraco; quando a 1 chega, W é listado com `{ seq: 1, left: true }`.
- Sem mudança, para conferir que nada mais se moveu, antes do merge com a `main` (3f7e8420): `packages/core/test/seeder-delete.test.js` 30/30 (263), `packages/core/test/sync-groups-3.test.js` 16/16 (71), `packages/core/test/seeder-groups.test.js` 43/43 (262), `packages/core/test/seeder-groups-3.test.js` 6/6 (33), `packages/core/test/seeder-groups-waits.test.js` 12/12 (61) e `packages/web-member/test/sync-groups-2.test.js` 26/26 (130).
- Depois do merge com a `main` (d2294699, com a #717): `seeder-groups-cuts` 13/13 (293), `seeder-delete` 35/35 (288, com o teste novo), `seeder-groups` 44/44 (270), `sync-groups-7` 1/1 (12) e `web-member sync-groups-3` 1/1 (14).
- Com a volta pela caminhada para a ligação não listada: `seeder-groups-cuts` 14/14 (296), `seeder-delete` 35/35 (288), `seeder-groups` 44/44 (270), `sync-groups-7` 1/1 (12) e `web-member sync-groups-3` 1/1 (14).
- `apps/cli/test/changelog.test.js` 9/9 (42) e `npm run lint` limpo.

## Prova de regressão

Com `packages/core/lib/seeder.js` da `main` (3f7e8420) e os testes desta branch:

- `seeder-groups-cuts`: 10/13 (283/293). Falham os dois testes de `liveGroupJoins` acima (por exemplo, "frozen and left: kept for its history, by its on join") e o teste de integração novo: "by its on join, the block readers check" (seq 2 no lugar de 1), "and stored with it", "listed left by its on join again" e o arquivo depois do reinício.
- `sync-groups-7`: 0/1 (7/12). O semeador lista o escritor de Bia com a seq 5 (a entrada desligada; a ligada é 4), e a sincronização de Ana o recusa: `group-skipped` com `reason: 'unbound'` (a listagem contada contra o semeador), sem `group-downloaded`, sem o núcleo guardado e sem a publicação "oi".
- `web-member sync-groups-3`: 0/1 (10/14). O mesmo no nó do navegador: `group-skipped` `unbound`, o escritor não fica guardado e "oi" não aparece.
- `seeder-delete`, com `packages/core/lib/seeder.js` da `main` d2294699: 34/35 (287/288). Falha só o teste novo: "listed left by the late on join, never the off one" dá seq 2 (a entrada desligada) no lugar de 1.
- `seeder-groups-cuts`, com `packages/core/lib/seeder.js` de 55b2ec73 (antes da volta pela caminhada para a ligação não listada): 13/14 (294/296). Falha só o teste da ligação não listada: "the binding takes its on join in G" dá 2 no lugar de 1, e a linha da página também sai com a seq 2.

Só com a mudança de `_reconcileGroups` desfeita (a de `liveGroupJoins` mantida), `seeder-groups-cuts` dá 12/13 (291/293): depois do reinício a página continua com a seq 2 que o arquivo trazia ("listed left by its on join again" e "and stored with it").

Nos dois testes ponta a ponta, sem a correção, a recusa depende de o semeador escanear a entrada desligada antes de admitir o escritor; se ele admitisse com a entrada ligada ainda sozinha no diário, a seq já sairia certa. Nas execuções acima a recusa apareceu toda vez. Os testes do semeador não dependem dessa ordem.

## Para o operador

Atualize os semeadores antes (ou no lugar) de qualquer app: a correção é toda do semeador e os apps instalados passam a aceitar a listagem sem atualizar nada. Um semeador já em produção com escritores guardados pela entrada desligada se corrige sozinho no primeiro escaneamento de cada diário depois de reiniciado.

## Fica de fora

- Nada foi exercitado em aparelho nem contra um semeador de produção.
- A suíte inteira e `npm run demo` não foram rodados nesta branch.
38 changes: 30 additions & 8 deletions packages/core/lib/seeder.js
Original file line number Diff line number Diff line change
Expand Up @@ -889,7 +889,9 @@ const ROOT_DENIALS_HARD = 2 * ROOT_CREATORS_MAX
// still counts their records (below the cut, and block 0, leaves and key
// blocks at any cut) and waits for them, but their join never picks a
// group, fetches a root or supports one (a root already held stays by the
// retention rule, _groupSupported).
// retention rule, _groupSupported). Such a writer is listed by its newest
// on:true join for the group (the walk counts a writer only after one):
// readers check the page item's seq against an on:true join naming it.
// writer -> { group, seq, left }.
function liveGroupJoins (decls, walks = new Map()) {
const allowed = new Set()
Expand Down Expand Up @@ -920,22 +922,29 @@ function liveGroupJoins (decls, walks = new Map()) {
const pair = d.group + ':' + writer
if (!released.has(pair) && (d.on || !allowed.has(pair))) continue
if (joined.has(d.group) && !groups.has(d.group)) continue
out.set(writer, { group: d.group, seq: d.seq, left: true })
const onSeq = walks.get(d.group).onSeq
const seq = onSeq === undefined ? undefined : onSeq.get(writer)
if (seq === undefined) continue
out.set(writer, { group: d.group, seq, left: true })
}
return out
}

// Steps one group-join or group-cut of a diary into its walk for that group
// (`walks`, group -> walk state), each seq once: the scan reads a diary in
// seq order and never steps back.
// seq order and never steps back. The state also keeps `onSeq`, writer ->
// the seq of its newest on:true join for the group, for the writers the
// walk counts or released only (so no more than the walk's caps per group).
function groupWalkStep (walks, group, e) {
let s = walks.get(group)
if (s === undefined) {
s = slotWalkState()
s.onSeq = new Map()
walks.set(group, s)
}
if (e.seq <= s.last) return
slotWalkStep(s, e, group)
if (e.kind === 'join' && e.on === true && s.state.has(e.writer)) s.onSeq.set(e.writer, e.seq)
}

// One valid group-join or group-cut record at diary seq `i` folded into the
Expand Down Expand Up @@ -2469,9 +2478,10 @@ class Seeder {
// the map grows no faster than groupDecls; and
// `groupWalks` the slot walk per group (group -> lib/group.js walk
// state) over its group-join and group-cut records, which picks the
// writers that count (liveGroupJoins), with `groupEvents` those
// records per group in seq order, to step a walk again when a deleted
// one arrives after the scan passed it.
// writers that count and keeps the newest on:true join of each
// (groupWalkStep, liveGroupJoins), with `groupEvents` those records
// per group in seq order, to step a walk again when a deleted one
// arrives after the scan passed it.
groupDecls: new Map(),
groupBound: new Map(),
groupWalks: new Map(),
Expand Down Expand Up @@ -4286,8 +4296,20 @@ class Seeder {
if (b === null || b.diary !== diary) continue
if (!this._groupServed.has(k)) continue
const live = entry.groupLive.get(k)
const bound = live !== undefined && live.group === b.group && !live.left
let seq = bound ? live.seq : b.seq
const listed = live !== undefined && live.group === b.group
const bound = listed && !live.left
// A left writer is listed by its newest on:true join too, so a binding
// stored with the seq of an off join takes it here. One the scan does
// not list (its diary named W in another group, the group is past the
// cap) still gets a row: the walk's newest on:true join of W, once the
// scan has read it.
let seq = b.seq
if (listed) seq = live.seq
else {
const s = entry.groupWalks.get(b.group)
const on = s === undefined || s.onSeq === undefined ? undefined : s.onSeq.get(k)
if (on !== undefined) seq = on
}
if (k === b.group) {
// A root's row must point at a join in its creator's own diary: the
// binding may have been persisted with the seq of the member join
Expand Down
21 changes: 21 additions & 0 deletions packages/core/test/seeder-delete.test.js
Original file line number Diff line number Diff line change
Expand Up @@ -1480,6 +1480,27 @@ test('a deleted group-cut that arrives after the scan steps the slot walk at its
t.alike(entry.groupLive.get(CUT_WRITERS[8]), { group: GROUP_KEY, seq: 10, left: false }, 'the ninth takes the slot it freed')
})

// A member joined a writer (seq 1), left (seq 2, the join off) and deleted
// the join (seq 3). The scan passed the join as a hole: when it arrives the
// walk counts the writer, which readers then check by that on join.
const LEFT_BLOCKS = [
{ type: 'member-cert', cert: { member: GROUP_DIARY } },
{ type: 'group-join', group: GROUP_KEY, writer: GROUP_WRITER, on: true, at: GROUP_AT },
{ type: 'group-join', group: GROUP_KEY, writer: GROUP_WRITER, on: false, at: GROUP_AT },
{ type: 'delete', seq: 1, at: GROUP_AT }
]

test('a deleted on join that arrives after the scan lists its left writer by that join (#350)', async (t) => {
const held = new Set(LEFT_BLOCKS.keys())
const { seeder, entry, reconciled } = groupFixture(held, LEFT_BLOCKS)
await seeder._pageArrived(GROUP_DIARY, entry, 2)
t.absent(entry.groupLive.has(GROUP_WRITER), 'an off join alone counts no writer')

await seeder._pageArrived(GROUP_DIARY, entry, 1)
t.alike(entry.groupLive.get(GROUP_WRITER), { group: GROUP_KEY, seq: 1, left: true }, 'listed left by the late on join, never the off one')
t.alike(reconciled.at(-1), [GROUP_DIARY, [GROUP_WRITER]], 'the group cores are reconciled with it')
})

test('a held group-join a tombstone targets never enters the deleted bookkeeping', async (t) => {
const { seeder, entry } = groupFixture(new Set([0, 1, 2, 3, 4]))
await learnGroupTombstones(seeder, entry)
Expand Down
Loading
Loading