Testclient: gedeelde afhankelijkheden, en zicht op de WebSocket
Een fout van ons, gevonden door de gebruiker bij de tweede eigenaar: "Expected tab leader port.". createEvoluDeps vraagt via navigator.locks het slot "tab" aan en kondigt de houder aan als tab leader, en dat slot kan er maar een hebben. openStore maakte per eigenaar een eigen stel afhankelijkheden, dus de tweede werd nooit leider. Nu een stel per proces met een teller, zodat het pas opgeruimd wordt als de laatste store sluit. Dit stond al als valstrik 2 in PLAN.md 4e en was er alsnog in geslopen; de toets met twee eigenaars tegelijk brengt hem terug zodra iemand dit ongedaan maakt. Twee dingen erbij om te kunnen zien wat er met de relay gebeurt: - spiegel <naam> opent dezelfde eigenaar in een lege database naast de bestaande. Alles wat daar binnenkomt heeft de heen- en terugreis over de relay gemaakt, en dat is de enige manier waarop de clientkant kan bewijzen dat er werkelijk iets op de relay staat; lees toont je altijd je eigen rijen. - onWebSocket meldt welke URL geopend wordt en wat ermee gebeurt. Zonder dat ziet een relay die de socket dichtgooit er hetzelfde uit als een trage relay. Dat luikje gaf meteen het antwoord: de socket komt nooit open, 1006, in een herhaallus, en met het ws-pakket ernaast staat er wat de globale WebSocket verzwijgt: 401. Twee eigenaars die eerder allebei 101 gaven zijn dus uit de allowlist van de relay verdwenen. Dat is een vraag over de server-app en staat als open punt 9, met vier verklaringen en wat ze uit elkaar houdt. Suite: 478 goed, 0 fout. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Harmen
@@ -46,7 +46,34 @@
|
||||
Voor de proeven is `klop` het antwoord, maar op de pagina staat een groen bolletje dat meer belooft dan
|
||||
het weet. Evolu heeft een `SyncState`; uitzoeken of daar iets bruikbaars in zit.
|
||||
|
||||
9. **Het afsluiten is opgelost maar niet doorgrond.** De volgorde in `dispose` (afhankelijkheden, dan een
|
||||
9. **Twee toegelaten eigenaars zijn uit de allowlist van de relay verdwenen (09-09-2026), en we weten
|
||||
niet waarom.** Ze gaven allebei 101 en even later allebei 401, met "turned away" op de statuspagina.
|
||||
Dit is een vraag over de **server-app**, niet over de cliënt, en het is de eerste keer dat dit
|
||||
gereedschap iets over de relay aan het licht brengt. Vier verklaringen, in volgorde van
|
||||
waarschijnlijkheid:
|
||||
|
||||
1. **de relay is herstart voordat de allowlist weggeschreven was.** `isOwnerAllowed` zet alleen
|
||||
`dirty`; het wegschrijven gebeurt in de lus. Een herstart in dat gat kost de net geleerde eigenaars.
|
||||
`restart: on-failure` staat in de compose, dus een herstart hoeft niet opgemerkt te zijn;
|
||||
2. **`owners.json` is als onleesbaar terzijde geschoven.** Daar heeft de relay een eigen logregel voor
|
||||
("owners.json was unreadable and has been moved aside"). Minder waarschijnlijk, want `writeState`
|
||||
schrijft via een tijdelijk bestand en een hernoeming, dus een halve schrijfactie hoort niet te
|
||||
kunnen;
|
||||
3. **de blob van 2 MB heeft de relay laten struikelen.** Die zat boven `RELAY_MAX_WRITE_BYTES` en werd
|
||||
vlak voor het verdwijnen geschreven. Als dat een herstart gaf, is dit verklaring 1 met een oorzaak;
|
||||
4. de leerstand liet ze toe zonder ze te bewaren, en dan is er iets mis in `store.js`.
|
||||
|
||||
**Wat het uit elkaar houdt zijn de logregels van de relay-container**, en die kan alleen de gebruiker
|
||||
lezen: `learned a new owner`, `owners.json was unreadable`, `refused a write of N bytes`, plus of de
|
||||
container herstart is. Die laatste regel is bovendien de proef over de bytegrens, die van de
|
||||
cliëntkant onzichtbaar is.
|
||||
|
||||
10. **De bytegrens is van de cliëntkant niet te zien.** Een blob van 2 MB schrijven levert geen enkele
|
||||
melding op: de cliënt is local-first, dus de rij staat er lokaal hoe dan ook, en de relay meldt een
|
||||
geweigerde schrijfactie alleen in zijn eigen log. `spiegel` kan het indirect aantonen (de blob komt
|
||||
dan niet terug), maar alleen als de synchronisatie verder werkt.
|
||||
|
||||
11. **Het afsluiten is opgelost maar niet doorgrond.** De volgorde in `dispose` (afhankelijkheden, dan een
|
||||
tik doorlaten, dan de resources van de gedeelde worker, dan de runs) is gevonden door te proberen, niet
|
||||
door de bron van Evolu te lezen. Hij werkt en er is een reden bij opgeschreven, maar het is geen bewijs.
|
||||
Valt het bij een volgende versie opnieuw om, lees dan eerst `Task.js` in plaats van opnieuw te schuiven.
|
||||
|
||||
@@ -60,3 +60,33 @@ dus de relay is over `wss://` bruikbaar. Dat raakt het masterplan **Bereikbaarhe
|
||||
|
||||
Wat deze cliënt niet kan zien, en dus bij de gebruiker ligt: staan die twee eigenaars in de weigerlijst op
|
||||
de statuspagina van de app?
|
||||
|
||||
## 09-09-2026 - een eigen fout, en daarna een vraag aan de relay
|
||||
|
||||
De gebruiker liet beide eigenaars toe en kreeg meteen een defect op de tweede: "Expected tab leader port.".
|
||||
**Een fout van ons, en precies de valstrik die in `PLAN.md` §4e als nummer 2 staat opgeschreven.**
|
||||
`createEvoluDeps` vraagt via `navigator.locks` het slot "tab" aan en kondigt de houder aan als tab leader;
|
||||
dat slot kan er maar één hebben. `openStore` maakte per eigenaar een eigen stel afhankelijkheden, dus de
|
||||
tweede werd nooit leider. In een browser is dit vanzelf goed: daar is er één tabblad met één gedeelde
|
||||
worker. Nu één stel per proces, met een teller zodat het pas opgeruimd wordt als de laatste store sluit,
|
||||
en een toets met twee eigenaars tegelijk die de fout terugbrengt zodra iemand dat ongedaan maakt.
|
||||
|
||||
Daarna bleek er niets te synchroniseren. Twee dingen erbij gebouwd om dat überhaupt te kúnnen zien:
|
||||
|
||||
- **`spiegel <naam>`** opent dezelfde eigenaar in een lege database naast de bestaande. Alles wat daar
|
||||
binnenkomt heeft de heenreis en de terugreis over de relay gemaakt, en dat is de enige manier waarop de
|
||||
cliëntkant kan bewijzen dat er werkelijk iets op de relay staat. `lees` toont je namelijk altijd je eigen
|
||||
rijen, ook als de relay ze nooit gezien heeft;
|
||||
- **een luikje op de WebSocket** (`onWebSocket`), dat meldt welke URL er geopend wordt en wat ermee
|
||||
gebeurt. Zonder dat ziet een relay die de socket dichtgooit er hetzelfde uit als een relay die traag is:
|
||||
Evolu probeert het gewoon opnieuw.
|
||||
|
||||
Dat luikje gaf het antwoord in één keer: de socket komt nooit open, `WebSocketConnectError` en sluitcode
|
||||
1006, in een herhaallus. Met het `ws`-pakket ernaast gelegd staat er wat de globale WebSocket verzwijgt:
|
||||
**HTTP 401.** En `klop` zegt dat inmiddels ook, voor allebei de eigenaars, terwijl diezelfde opdracht
|
||||
kort daarvoor nog twee keer 101 gaf.
|
||||
|
||||
**Daarmee ligt de vraag bij de relay en niet meer bij de cliënt: twee eigenaars die toegelaten waren zijn
|
||||
uit de allowlist verdwenen.** Wat er op de statuspagina van staat is "turned away". Wat dit kan zijn staat
|
||||
in [OPEN.md](OPEN.md) punt 10; het antwoord zit in de logregels van de relay-container en die kan alleen de
|
||||
gebruiker lezen.
|
||||
|
||||
@@ -12,10 +12,11 @@
|
||||
|
||||
## Volgende stap
|
||||
|
||||
- [ ] **Het venster voor nieuwe eigenaars openzetten op de statuspagina van de app, en dan de rest van
|
||||
fase 4.** De eerste proef is gedaan: de relay is bereikbaar over `wss://` en weigert een onbekende
|
||||
eigenaar met 401. De volgende proeven vragen om een eigenaar die er wél in mag, en die knop zit
|
||||
achter de inlog van umbrelOS. **Eigenaar: gebruiker**
|
||||
- [ ] **De logregels van de relay-container lezen, want daar zit het antwoord op [OPEN.md](OPEN.md) punt
|
||||
9.** Twee eigenaars die toegelaten waren zijn uit de allowlist verdwenen, en de cliënt kan niet zien
|
||||
waarom. Gezocht wordt naar `learned a new owner`, `owners.json was unreadable`, `refused a write of
|
||||
N bytes`, en of de container herstart is. **Eigenaar: gebruiker**, want alleen die komt bij het
|
||||
apparaat. Die laatste regel is meteen de proef over de bytegrens, die van de cliëntkant onzichtbaar is
|
||||
|
||||
## Fase 1 - de samenstelling (af)
|
||||
|
||||
|
||||
@@ -148,6 +148,45 @@ try {
|
||||
store = null;
|
||||
await nogmaalsSluiten();
|
||||
|
||||
// ── Twee eigenaars tegelijk ────────────────────────────────────────────────
|
||||
//
|
||||
// Dit is de toets voor de fout die de gebruiker op 09-09-2026 vond, en het is
|
||||
// een fout die met één eigenaar onzichtbaar is. `createEvoluDeps` vraagt het
|
||||
// slot "tab" aan en kondigt de houder aan als tab leader; dat slot kan er maar
|
||||
// één hebben. Werd dat per eigenaar aangeroepen, dan werd de tweede nooit
|
||||
// leider en brak zijn database-worker af met "Expected tab leader port.".
|
||||
const eersteVanTwee = await openStore({
|
||||
directory: map,
|
||||
owner: nieuweEigenaar(),
|
||||
onDefect: (defect) => defecten.push(defect),
|
||||
});
|
||||
const tweedeVanTwee = await openStore({
|
||||
directory: map,
|
||||
owner: nieuweEigenaar(),
|
||||
onDefect: (defect) => defecten.push(defect),
|
||||
});
|
||||
|
||||
try {
|
||||
await eersteVanTwee.schrijf('van de eerste', new Uint8Array([1]));
|
||||
await tweedeVanTwee.schrijf('van de tweede', new Uint8Array([2, 2]));
|
||||
|
||||
const vanEerste = await eersteVanTwee.lees();
|
||||
const vanTweede = await tweedeVanTwee.lees();
|
||||
|
||||
toets('twee eigenaars kunnen tegelijk schrijven', vanEerste.length === 1 && vanTweede.length === 1);
|
||||
// En ze zien elkaars gegevens niet, want dat is de hele belofte van een
|
||||
// eigenaar. Zou dat wél zo zijn, dan deelden ze een database.
|
||||
toets('en ze zien elkaars blobs niet', vanEerste[0]?.label === 'van de eerste' && vanTweede[0]?.label === 'van de tweede');
|
||||
|
||||
// De eerste sluiten mag de tweede niet slopen: de afhankelijkheden zijn
|
||||
// gedeeld, dus ze gaan pas weg als de laatste store dicht is.
|
||||
await eersteVanTwee.sluit();
|
||||
const naSluiten = await tweedeVanTwee.lees();
|
||||
toets('de tweede blijft werken als de eerste sluit', naSluiten.length === 1);
|
||||
} finally {
|
||||
await tweedeVanTwee.sluit();
|
||||
}
|
||||
|
||||
// Afsluiten hoort stil te zijn. Ging dat mis, dan bleef er een worker draaien
|
||||
// die zijn eigen run al kwijt was, en dat merk je pas als een proces blijft
|
||||
// hangen. Dat was de vierde valstrik uit PLAN.md §4e.
|
||||
|
||||
@@ -13,6 +13,7 @@ export const OPDRACHTEN = {
|
||||
schrijf: { argumenten: ['naam', 'label'], uitleg: 'Schrijft een blob weg voor deze eigenaar' },
|
||||
lees: { argumenten: ['naam'], uitleg: 'Toont de blobs van deze eigenaar' },
|
||||
klop: { argumenten: ['naam'], uitleg: 'Klopt aan bij de relay en toont de HTTP-status' },
|
||||
spiegel: { argumenten: ['naam'], uitleg: 'Haalt deze eigenaar op in een lege database, via de relay' },
|
||||
sync: { argumenten: ['naam'], uitleg: 'Verbindt en blijft draaien tot Ctrl-C' },
|
||||
vergeet: { argumenten: ['naam'], uitleg: 'Haalt een eigenaar uit het register' },
|
||||
ui: { argumenten: [], uitleg: 'Start het bedieningsvlak in de browser' },
|
||||
@@ -92,6 +93,7 @@ export const gebruiksaanwijzing = () => {
|
||||
regels.push('Vlaggen:');
|
||||
regels.push(' --bytes <n> Omvang van de blob bij `schrijf` (standaard 64)');
|
||||
regels.push(' --lokaal Schrijven zonder de relay, bij `schrijf`');
|
||||
regels.push(' --wacht <n> Seconden wachten op de relay, bij `spiegel` (standaard 15)');
|
||||
regels.push(' --poort <n> Poort van het bedieningsvlak bij `ui`');
|
||||
regels.push('');
|
||||
regels.push('Het adres van de relay komt uit .env; zie .env.sample.');
|
||||
|
||||
@@ -11,6 +11,8 @@
|
||||
// scherm komt.
|
||||
// ═══════════════════════════════════════════════════════════════════════════════
|
||||
|
||||
import { mkdtempSync, rmSync } from 'node:fs';
|
||||
import { tmpdir } from 'node:os';
|
||||
import { join } from 'node:path';
|
||||
|
||||
import { gebruiksaanwijzing, leesArgumenten } from './argumenten.js';
|
||||
@@ -48,6 +50,11 @@ const openVoor = (regel, { metRelay }) =>
|
||||
console.error(defect);
|
||||
process.exit(1);
|
||||
},
|
||||
// Wat Evolu wérkelijk opent, en niet wat wij hem meegaven. De `OwnerId` in
|
||||
// die URL is wat de relay ziet en dus wie er toegelaten of geweigerd wordt.
|
||||
onWebSocket: (m) => {
|
||||
console.log(` socket ${m.wat}: ${m.url}${m.detail ? ` (${m.detail})` : ""}`);
|
||||
},
|
||||
});
|
||||
|
||||
const eisRelay = () => {
|
||||
@@ -154,6 +161,76 @@ const opdrachten = {
|
||||
process.exit(uitkomst.geaccepteerd ? 0 : 1);
|
||||
},
|
||||
|
||||
spiegel: async ({ naam }, vlaggen) => {
|
||||
// De enige proef die van de cliëntkant kan bewijzen dat er werkelijk iets op
|
||||
// de relay staat. Dezelfde eigenaar, een lege database ernaast: alles wat
|
||||
// hier binnenkomt heeft de heenreis en de terugreis gemaakt.
|
||||
//
|
||||
// Waarom dit nodig is: de cliënt is local-first, dus `lees` toont je altijd
|
||||
// je eigen rijen, ook als de relay ze nooit gezien heeft. Wat de relay
|
||||
// bewaart is van hier niet te zien; dit is de omweg eromheen.
|
||||
eisRelay();
|
||||
const { regel } = haalEigenaarOp(naam);
|
||||
const seconden = Number.parseInt(vlaggen.wacht ?? '15', 10);
|
||||
|
||||
const tijdelijk = mkdtempSync(join(tmpdir(), 'relay-client-spiegel-'));
|
||||
console.log(`"${naam}" opnieuw opgehaald in een lege database.`);
|
||||
console.log(` ${tijdelijk}`);
|
||||
console.log(` ${config.relayUrl}`);
|
||||
console.log('');
|
||||
|
||||
const store = await openStore({
|
||||
directory: tijdelijk,
|
||||
owner: eigenaarUitMnemonic(regel.mnemonic),
|
||||
relayUrl: config.relayUrl,
|
||||
onWebSocket: (m) => { console.log(` socket ${m.wat}: ${m.url}${m.detail ? ` (${m.detail})` : ""}`); },
|
||||
onDefect: (defect) => {
|
||||
console.error('Defect uit een worker, de opdracht wordt afgebroken:');
|
||||
console.error(defect);
|
||||
process.exit(1);
|
||||
},
|
||||
});
|
||||
|
||||
try {
|
||||
// Peilen tot het aantal een paar rondes stil blijft. Er is geen signaal
|
||||
// "hier ben ik klaar": Evolu synchroniseert en blijft synchroniseren.
|
||||
let vorige = -1;
|
||||
let stil = 0;
|
||||
for (let ronde = 0; ronde < seconden * 2; ronde += 1) {
|
||||
await new Promise((klaar) => {
|
||||
setTimeout(klaar, 500);
|
||||
});
|
||||
const nu = (await store.lees()).length;
|
||||
if (nu === vorige && nu > 0) {
|
||||
stil += 1;
|
||||
if (stil >= 6) break;
|
||||
} else {
|
||||
stil = 0;
|
||||
}
|
||||
vorige = nu;
|
||||
}
|
||||
|
||||
const rijen = await store.lees();
|
||||
if (rijen.length === 0) {
|
||||
console.log('Er kwam niets terug.');
|
||||
console.log('');
|
||||
console.log('Dat kan twee dingen betekenen en de cliënt kan ze niet uit elkaar houden:');
|
||||
console.log('de relay heeft niets van deze eigenaar, of hij was er nog niet klaar mee.');
|
||||
console.log('Probeer `--wacht 60` en kijk anders op de statuspagina van de app.');
|
||||
return;
|
||||
}
|
||||
console.log(`${rijen.length} blob(s) terug van de relay:`);
|
||||
for (const rij of rijen) {
|
||||
console.log(` ${rij.id} ${String(rij.body?.length ?? 0).padStart(8)} bytes ${rij.label}`);
|
||||
}
|
||||
} finally {
|
||||
await store.sluit();
|
||||
// Eigen tijdelijke map, dus die ruimt deze opdracht zelf op. Er zit een
|
||||
// database van een echte eigenaar in.
|
||||
rmSync(tijdelijk, { recursive: true, force: true });
|
||||
}
|
||||
},
|
||||
|
||||
sync: async ({ naam }) => {
|
||||
eisRelay();
|
||||
const { regel } = haalEigenaarOp(naam);
|
||||
|
||||
@@ -67,6 +67,70 @@ const allesQuery = createQueryBuilder(Schema)((db) =>
|
||||
db.selectFrom('blob').selectAll().orderBy('createdAt'),
|
||||
);
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════════════════
|
||||
// De gedeelde afhankelijkheden: één stel per proces, voor alle eigenaars samen.
|
||||
//
|
||||
// Dat is geen zuinigheid maar een eis. `createEvoluDeps` vraagt via
|
||||
// `navigator.locks` het slot "tab" aan en kondigt de houder ervan aan als "tab
|
||||
// leader"; de database-worker van een instantie breekt af met "Expected tab
|
||||
// leader port." als die aankondiging er niet is. Eén slot betekent één houder,
|
||||
// dus een tweede stel afhankelijkheden in hetzelfde proces wordt nooit leider en
|
||||
// de tweede eigenaar valt om.
|
||||
//
|
||||
// Precies dat gebeurde op 09-09-2026 bij de gebruiker, bij de tweede eigenaar.
|
||||
// Het stond al als valstrik 2 in PLAN.md §4e en in het commentaar van
|
||||
// evolu-node.js ("Eén keer aanroepen en hergebruiken voor alle eigenaars"), en
|
||||
// het was er alsnog in geslopen omdat `openStore` per aanroep een eigen stel
|
||||
// maakte. In een browser is dit vanzelf goed: daar is er één tabblad met één
|
||||
// gedeelde worker voor alle instanties.
|
||||
//
|
||||
// Meegeteld wordt hoeveel stores er open zijn, zodat het pas wordt opgeruimd als
|
||||
// de laatste sluit.
|
||||
// ═══════════════════════════════════════════════════════════════════════════════
|
||||
|
||||
let gedeeld = null;
|
||||
|
||||
/** Wie er een defect wil horen. Per open store één, en die gaat er bij het sluiten uit. */
|
||||
const defectMelders = new Set();
|
||||
|
||||
/** Wie er wil weten welke WebSocket-URL er werkelijk geopend wordt. */
|
||||
const socketMelders = new Set();
|
||||
|
||||
const haalGedeeldeDeps = (directory, consoleLevel) => {
|
||||
if (gedeeld === null) {
|
||||
const { deps, dispose } = createNodeEvoluDeps({
|
||||
directory,
|
||||
consoleLevel,
|
||||
onDefect: (defect) => {
|
||||
// Naar iedereen die luistert. Een defect komt uit een gedeelde worker en
|
||||
// is dus niet aan één eigenaar toe te schrijven; doen alsof van wel zou
|
||||
// het onderzoek de verkeerde kant op sturen.
|
||||
for (const melder of defectMelders) melder(defect);
|
||||
},
|
||||
onWebSocket: (url) => {
|
||||
for (const melder of socketMelders) melder(url);
|
||||
},
|
||||
});
|
||||
gedeeld = { directory, deps, dispose, aantal: 0 };
|
||||
} else if (gedeeld.directory !== directory) {
|
||||
throw new Error(
|
||||
`Er is al een gegevensmap open (${gedeeld.directory}). Eén map per proces; `
|
||||
+ 'sluit eerst alle stores voordat je een andere map gebruikt.',
|
||||
);
|
||||
}
|
||||
gedeeld.aantal += 1;
|
||||
return gedeeld.deps;
|
||||
};
|
||||
|
||||
const laatGedeeldeDepsLos = async () => {
|
||||
if (gedeeld === null) return;
|
||||
gedeeld.aantal -= 1;
|
||||
if (gedeeld.aantal > 0) return;
|
||||
const weg = gedeeld;
|
||||
gedeeld = null;
|
||||
await weg.dispose();
|
||||
};
|
||||
|
||||
/** Maakt een nieuwe eigenaar met verse sleutels. */
|
||||
export const nieuweEigenaar = () =>
|
||||
createAppOwner(createOwnerSecret({ randomBytes: createRandomBytes() }));
|
||||
@@ -90,8 +154,21 @@ export const eigenaarUitMnemonic = (mnemonic) => createAppOwner(mnemonicToOwnerS
|
||||
*
|
||||
* @param {{directory: string, owner: object, relayUrl?: string, onDefect?: Function, consoleLevel?: string}} config
|
||||
*/
|
||||
export const openStore = async ({ directory, owner, relayUrl, onDefect, consoleLevel = 'error' }) => {
|
||||
const { deps, dispose } = createNodeEvoluDeps({ directory, consoleLevel, onDefect });
|
||||
export const openStore = async ({
|
||||
directory,
|
||||
owner,
|
||||
relayUrl,
|
||||
onDefect,
|
||||
onWebSocket,
|
||||
consoleLevel = 'error',
|
||||
}) => {
|
||||
const deps = haalGedeeldeDeps(directory, consoleLevel);
|
||||
if (onDefect) defectMelders.add(onDefect);
|
||||
if (onWebSocket) socketMelders.add(onWebSocket);
|
||||
|
||||
// Wél een eigen run per store, want die bezit de instantie: één eigenaar
|
||||
// sluiten hoort de andere niet te raken. Alleen de afhankelijkheden eronder
|
||||
// zijn gedeeld.
|
||||
const run = createRun(deps);
|
||||
|
||||
// Het OwnerId gaat mee in de URL, en dat is wat de relay bij de
|
||||
@@ -108,7 +185,9 @@ export const openStore = async ({ directory, owner, relayUrl, onDefect, consoleL
|
||||
|
||||
if (!uitkomst.ok) {
|
||||
await run[Symbol.asyncDispose]();
|
||||
await dispose();
|
||||
if (onDefect) defectMelders.delete(onDefect);
|
||||
if (onWebSocket) socketMelders.delete(onWebSocket);
|
||||
await laatGedeeldeDepsLos();
|
||||
throw new Error(`Evolu wilde niet starten: ${JSON.stringify(uitkomst.error)}`);
|
||||
}
|
||||
|
||||
@@ -144,10 +223,15 @@ export const openStore = async ({ directory, owner, relayUrl, onDefect, consoleL
|
||||
* Sluit af. Eerst de run, dan de afhankelijkheden: de run bezit de instantie
|
||||
* en die gebruikt de workers die in de afhankelijkheden zitten. Andersom
|
||||
* eindigt elk afsluiten met een SuppressedError zonder oorzaak.
|
||||
*
|
||||
* De gedeelde afhankelijkheden gaan pas weg als de láátste store sluit; zie
|
||||
* de uitleg bovenaan bij `gedeeld`.
|
||||
*/
|
||||
sluit: async () => {
|
||||
await run[Symbol.asyncDispose]();
|
||||
await dispose();
|
||||
if (onDefect) defectMelders.delete(onDefect);
|
||||
if (onWebSocket) socketMelders.delete(onWebSocket);
|
||||
await laatGedeeldeDepsLos();
|
||||
},
|
||||
};
|
||||
};
|
||||
|
||||
@@ -63,7 +63,7 @@ const createSqliteDriverIn = (directory) => (name, options) =>
|
||||
*
|
||||
* @param {{directory: string, consoleLevel?: string}} config
|
||||
*/
|
||||
export const createNodeEvoluDeps = ({ directory, consoleLevel = 'warn', onDefect }) => {
|
||||
export const createNodeEvoluDeps = ({ directory, consoleLevel = 'warn', onDefect, onWebSocket }) => {
|
||||
// De map moet er zijn vóórdat better-sqlite3 hem opent; die maakt hem niet aan
|
||||
// en gooit "Cannot open database because the directory does not exist". Dat
|
||||
// gebeurt binnen een worker, dus zonder deze regel is het symptoom een
|
||||
@@ -111,11 +111,46 @@ export const createNodeEvoluDeps = ({ directory, consoleLevel = 'warn', onDefect
|
||||
reportDefect,
|
||||
});
|
||||
|
||||
// De WebSocket met een luikje erin. Wat Evolu werkelijk opent is namelijk niet
|
||||
// af te leiden uit wat je hem meegeeft: de `OwnerId` in de URL bepaalt wie de
|
||||
// relay ziet, en dat is precies de vraag waar dit gereedschap over gaat. Zonder
|
||||
// dit luikje kun je alleen gissen waarom er een geweigerde eigenaar op de
|
||||
// statuspagina verschijnt.
|
||||
//
|
||||
// Niet alleen welke URL, maar ook wat ermee gebeurt. Een relay die de socket
|
||||
// meteen weer dichtgooit ziet er van de cliëntkant hetzelfde uit als een relay
|
||||
// die traag is: Evolu probeert het gewoon opnieuw. De sluitcode is wat die twee
|
||||
// uit elkaar houdt.
|
||||
const gevolgdeWebSocket = onWebSocket
|
||||
? (url, options = {}) => {
|
||||
onWebSocket({ wat: 'openen', url });
|
||||
return createWebSocket(url, {
|
||||
...options,
|
||||
onOpen: () => {
|
||||
onWebSocket({ wat: 'open', url });
|
||||
options.onOpen?.();
|
||||
},
|
||||
onError: (fout) => {
|
||||
onWebSocket({ wat: 'fout', url, detail: fout?.type ?? String(fout) });
|
||||
options.onError?.(fout);
|
||||
},
|
||||
onClose: (gebeurtenis) => {
|
||||
onWebSocket({
|
||||
wat: 'dicht',
|
||||
url,
|
||||
detail: `code ${gebeurtenis?.code ?? '?'}${gebeurtenis?.reason ? ` ${gebeurtenis.reason}` : ''}`,
|
||||
});
|
||||
options.onClose?.(gebeurtenis);
|
||||
},
|
||||
});
|
||||
}
|
||||
: createWebSocket;
|
||||
|
||||
const sharedRun = createRun({
|
||||
...workerDeps,
|
||||
createBroadcastChannel,
|
||||
createMessageChannel,
|
||||
createWebSocket,
|
||||
createWebSocket: gevolgdeWebSocket,
|
||||
lockManager,
|
||||
reportDefect,
|
||||
});
|
||||
|
||||
Reference in New Issue
Block a user