From 9ebc562c831ee90facbe8b1d2a4f9d3de80bfbb6 Mon Sep 17 00:00:00 2001 From: Claude Date: Sun, 18 Oct 2026 05:34:51 +0000 Subject: [PATCH] =?UTF-8?q?Workers=20P2:=20Zeitgrenze=20je=20Abruf=20und?= =?UTF-8?q?=20Sperre=20f=C3=BCr=20frische=20JWTs=20nach=20einer=20401-Folg?= =?UTF-8?q?e?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Endprüfung P2. Ein Abruf auf toter Verbindung (Rechner im Ruhezustand, Netzwechsel) blieb offen, und die Feed-Schleifen laufen mit einem Abruf je Schleife: die Seite stand still und zeigte veraltete Daten als aktuell. createWorkersApi bricht jetzt jeden Versuch (JWT holen, senden, Antwort lesen) nach 20 s mit "Der Hustler-Dienst ist gerade nicht erreichbar." (status 0) ab, auch wenn fetch oder createJWT das Signal nicht beachten. Außerdem erzwang jede 401-Antwort ein frisches createJWT, bei dauerhaftem 401 etwa 16 bis 20 Mal je Minute und Tab. Appwrite begrenzt createJWT je Nutzer; das Limit hätte auch Serverpuls, Finanzen und Vorschauen gesperrt. Nach einer 401-Folge (frisches JWT wird ebenfalls abgelehnt oder lässt sich nicht erzeugen) gibt es 2 Minuten lang kein frisches JWT mehr, die Meldung "Anmeldung abgelaufen" bleibt; Erfolg hebt die Sperre auf. Co-Authored-By: Claude Sonnet 5.5 --- src/lib/workersApi.js | 75 +++++++++++++++--- tests/unit/workersApi.test.mjs | 133 +++++++++++++++++++++++++++++++- tests/unit/workersFeed.test.mjs | 37 +++++++++ 3 files changed, 234 insertions(+), 11 deletions(-) diff --git a/src/lib/workersApi.js b/src/lib/workersApi.js index 1f980ae..fb13635 100644 --- a/src/lib/workersApi.js +++ b/src/lib/workersApi.js @@ -7,6 +7,14 @@ export const BAD_REPLY_TEXT = 'Der Hustler-Dienst antwortet nicht richtig.' export const SESSION_TEXT = 'Anmeldung abgelaufen. Bitte neu anmelden.' export const FORBIDDEN_TEXT = 'Dafür fehlt dir die Berechtigung.' +// Zeitgrenze je Abruf (JWT holen, senden, Antwort lesen): ohne sie bliebe ein Abruf auf toter Verbindung (Rechner im Ruhezustand, +// Netzwechsel) minutenlang offen und der Feed (ein Abruf je Schleife) stünde still, ohne Fehlermeldung. +export const REQUEST_TIMEOUT_MS = 20000 +// Nach einer 401-Folge (frisches JWT wird ebenfalls abgelehnt oder lässt sich nicht erzeugen) wird so lange kein frisches JWT mehr +// erzwungen: Appwrite begrenzt createJWT je Nutzer, und die Schleifen (5 s / 15 s) würden das Limit binnen Minuten aufbrauchen +// und damit auch Serverpuls, Finanzen und Vorschauen sperren. 2 Minuten ergeben höchstens 30 Versuche je Stunde und Tab. +export const AUTH_COOLDOWN_MS = 120000 + // Pult-Status des Dienstes (Übersicht §4.11) export const PULT_STATUS = Object.freeze(['offen', 'in_arbeit', 'gesendet', 'verworfen', 'veraltet', 'erledigt']) // Erlaubte Aktionen am Pult-Eintrag; alles andere wird abgewiesen, bevor ein Pfad entsteht @@ -46,13 +54,35 @@ function pultStatusList(status) { return list } -export function createWorkersApi({ getJwt, fetchImpl = (...args) => globalThis.fetch(...args) }) { +export function createWorkersApi({ + getJwt, + fetchImpl = (...args) => globalThis.fetch(...args), + timeoutMs = REQUEST_TIMEOUT_MS, + authCooldownMs = AUTH_COOLDOWN_MS, + now = Date.now, +}) { + let freshBlockedUntil = 0 // bis dahin wird nach einer 401-Antwort kein frisches JWT erzeugt (AUTH_COOLDOWN_MS) + + // Führt fn(signal) mit Zeitgrenze aus: nach timeoutMs scheitert der Aufruf mit DOWN_TEXT (status 0) und das Signal wird + // abgebrochen. Das gilt auch, wenn fn das Signal nicht beachtet (hängendes createJWT, fetchImpl ohne Abbruch-Unterstützung). + function withDeadline(fn) { + const controller = new AbortController() + let timer + const expired = new Promise((_, reject) => { + timer = setTimeout(() => { + reject(statusError(DOWN_TEXT, 0)) // zuerst ablehnen, dann abbrechen: das Abbruch-Ergebnis von fn soll nicht gewinnen + controller.abort() + }, timeoutMs) + }) + return Promise.race([fn(controller.signal), expired]).finally(() => clearTimeout(timer)) + } + // fetch wirft (Netz, Dienst aus) ⇒ DOWN_TEXT mit status 0 - async function send(path, method, body, jwt) { + async function send(path, method, body, jwt, signal) { const headers = { 'X-Appwrite-JWT': jwt } if (body !== undefined) headers['Content-Type'] = 'application/json' try { - return await fetchImpl(`${BASE}${path}`, { method, headers, body: body === undefined ? undefined : JSON.stringify(body) }) + return await fetchImpl(`${BASE}${path}`, { method, headers, body: body === undefined ? undefined : JSON.stringify(body), signal }) } catch { throw statusError(DOWN_TEXT, 0) } @@ -66,13 +96,8 @@ export function createWorkersApi({ getJwt, fetchImpl = (...args) => globalThis.f } } - async function request(path, { method = 'GET', body } = {}) { - let res = await send(path, method, body, await jwtFor()) - if (res.status === 401) { - // einmal mit frischem JWT wiederholen, danach gilt die Sitzung als abgelaufen - res = await send(path, method, body, await jwtFor({ fresh: true })) - if (res.status === 401) throw statusError(SESSION_TEXT, 401) - } + // Antwort auswerten (kein 401): Daten oder Error mit deutscher Meldung + async function read(res) { let data try { data = await res.json() @@ -90,6 +115,36 @@ export function createWorkersApi({ getJwt, fetchImpl = (...args) => globalThis.f return data ?? {} } + // Ein Versuch mit Zeitgrenze: JWT holen, senden, auswerten. { unauthorized: true } bei 401, sonst { data }. + function attempt(path, method, body, options) { + return withDeadline(async (signal) => { + const res = await send(path, method, body, await jwtFor(options), signal) + if (res.status === 401) return { unauthorized: true } + freshBlockedUntil = 0 // der Dienst hat das JWT angenommen: die nächste 401-Folge darf wieder einmal erneuern + return { data: await read(res) } + }) + } + + async function request(path, { method = 'GET', body } = {}) { + let out = await attempt(path, method, body) + if (out.unauthorized) { + // Während der Sperre gilt die 401 sofort als abgelaufene Sitzung (kein createJWT, keine zweite Anfrage) + if (now() < freshBlockedUntil) throw statusError(SESSION_TEXT, 401) + // sonst einmal mit frischem JWT wiederholen, danach gilt die Sitzung als abgelaufen und die Sperre beginnt + try { + out = await attempt(path, method, body, { fresh: true }) + } catch (err) { + if (err && err.status === 401) freshBlockedUntil = now() + authCooldownMs // auch das frische JWT ließ sich nicht erzeugen + throw err + } + if (out.unauthorized) { + freshBlockedUntil = now() + authCooldownMs + throw statusError(SESSION_TEXT, 401) + } + } + return out.data + } + return { state: () => request('/state'), events: (after, limit = EVENTS_LIMIT) => request(`/events${query([['after', after], ['limit', clampLimit(limit, EVENTS_LIMIT)]])}`), diff --git a/tests/unit/workersApi.test.mjs b/tests/unit/workersApi.test.mjs index 84b8760..1d91a8d 100644 --- a/tests/unit/workersApi.test.mjs +++ b/tests/unit/workersApi.test.mjs @@ -3,7 +3,7 @@ import assert from 'node:assert/strict' import { loadModule } from './load.mjs' // API-Client der Hustler-Seite: URLs, Methoden, Header, deutsche Fehlertexte, JWT-Wiederholung, Pult-Prüfungen -const { createWorkersApi } = await loadModule('src/lib/workersApi.js') +const { createWorkersApi, REQUEST_TIMEOUT_MS, AUTH_COOLDOWN_MS } = await loadModule('src/lib/workersApi.js') const jwts = [] const getJwt = async (o) => { @@ -144,3 +144,134 @@ test('limit wird geklemmt (Ereignisse 1..200, Spur 1..50)', async () => { '/api/workers/events?limit=150', ]) }) + +// ---- Endprüfung P2: Zeitgrenze je Abruf und Sperre für frische JWTs nach einer 401-Folge ---- + +const DOWN = 'Der Hustler-Dienst ist gerade nicht erreichbar.' +const SESSION = 'Anmeldung abgelaufen. Bitte neu anmelden.' + +test('Zeitgrenze: ein hängender fetch endet mit der Dienst-Meldung (status 0), das Signal wird abgebrochen', async () => { + const signals = [] + const hang = (url, init) => { + signals.push(init.signal) + return new Promise(() => {}) // beachtet das Signal nicht einmal: die Zeitgrenze muss trotzdem greifen + } + const api = createWorkersApi({ getJwt, fetchImpl: hang, timeoutMs: 30 }) + const t0 = Date.now() + await assert.rejects(api.state(), { message: DOWN, status: 0 }) + assert.ok(Date.now() - t0 < 2000) + assert.equal(signals.length, 1) + assert.equal(signals[0].aborted, true) + // jeder Aufruf hat seine eigene Zeitgrenze (hier: Schreibaufruf und Spur) + await assert.rejects(api.pause(true), { message: DOWN, status: 0 }) + await assert.rejects(api.trace('kim'), { message: DOWN, status: 0 }) + assert.equal(signals.length, 3) +}) + +test('Zeitgrenze: auch eine Antwort, deren Rumpf nie ankommt, und ein hängendes createJWT enden mit der Dienst-Meldung', async () => { + const stalledBody = async () => ({ ok: true, status: 200, json: () => new Promise(() => {}) }) + await assert.rejects(createWorkersApi({ getJwt, fetchImpl: stalledBody, timeoutMs: 30 }).state(), { message: DOWN, status: 0 }) + const hungJwt = () => new Promise(() => {}) + const f = fakeFetch(okReplies(1)) + await assert.rejects(createWorkersApi({ getJwt: hungJwt, fetchImpl: f, timeoutMs: 30 }).state(), { message: DOWN, status: 0 }) + assert.equal(f.calls.length, 0) // ohne JWT ging nichts hinaus +}) + +test('Zeitgrenze: rechtzeitige Antworten bleiben unberührt, ein späterer Abruf klappt wieder (Schleife wird frei)', async () => { + let n = 0 + const flaky = async () => { + n += 1 + if (n === 1) return new Promise(() => {}) + return { ok: true, status: 200, json: async () => ({ n }) } + } + const api = createWorkersApi({ getJwt, fetchImpl: flaky, timeoutMs: 40 }) + await assert.rejects(api.state(), { message: DOWN, status: 0 }) + assert.deepEqual(await api.state(), { n: 2 }) + const quick = createWorkersApi({ getJwt, fetchImpl: fakeFetch(okReplies(1)) }) // Standard-Zeitgrenze 20 s: wird nach der Antwort aufgeräumt + assert.deepEqual(await quick.state(), {}) +}) + +test('Zeitgrenze: Standardwerte 20 s und 2 min', () => { + assert.equal(REQUEST_TIMEOUT_MS, 20000) + assert.equal(AUTH_COOLDOWN_MS, 120000) +}) + +test('401-Folge: danach kein frisches JWT mehr, bis die Sperre abgelaufen ist (höchstens ein createJWT je Sperre)', async () => { + jwts.length = 0 + let t = 1_000_000 + const calls = [] + const always401 = async (url, init) => { + calls.push(init.headers['X-Appwrite-JWT']) + return { ok: false, status: 401, json: async () => ({}) } + } + const api = createWorkersApi({ getJwt, fetchImpl: always401, now: () => t, authCooldownMs: 60000 }) + await assert.rejects(api.state(), { message: SESSION, status: 401 }) + assert.deepEqual(jwts, [false, true]) + assert.deepEqual(calls, ['jwt-alt', 'jwt-neu']) // Versuch und Wiederholung + + // innerhalb der Sperre: je Abruf genau eine Anfrage mit dem gespeicherten JWT, nie ein frisches, die Meldung bleibt + for (let i = 0; i < 20; i += 1) { + t += 2900 // 20 Schleifendurchläufe innerhalb der Sperre von 60 s (Zustand, Ereignisse und Spur zusammen) + await assert.rejects(api.events(null), { message: SESSION, status: 401 }) + } + assert.equal(jwts.filter((fresh) => fresh).length, 1) + assert.equal(calls.length, 2 + 20) + + // nach Ablauf der Sperre wird wieder einmal erneuert, danach beginnt die nächste Sperre + t += 2100 + await assert.rejects(api.state(), { message: SESSION, status: 401 }) + assert.equal(jwts.filter((fresh) => fresh).length, 2) + t += 5000 + await assert.rejects(api.trace('kim'), { message: SESSION, status: 401 }) + assert.equal(jwts.filter((fresh) => fresh).length, 2) +}) + +test('401-Folge: Erfolg hebt die Sperre auf, ein einzelnes 401 danach wird wieder mit frischem JWT wiederholt', async () => { + jwts.length = 0 + let t = 0 + const replies = [ + { status: 401, body: {} }, { status: 401, body: {} }, // Folge ⇒ Sperre + { status: 200, body: { ok: 1 } }, // Dienst nimmt das gespeicherte JWT wieder an ⇒ Sperre weg + { status: 401, body: {} }, { status: 200, body: { ok: 2 } }, // einzelnes 401 ⇒ Wiederholung mit frischem JWT hilft + ] + const api = createWorkersApi({ getJwt, fetchImpl: fakeFetch(replies), now: () => t }) + await assert.rejects(api.state(), { status: 401 }) + t += 5000 + assert.deepEqual(await api.state(), { ok: 1 }) + assert.deepEqual(await api.state(), { ok: 2 }) + assert.deepEqual(jwts, [false, true, false, false, true]) +}) + +test('401-Folge: scheitert schon die Erzeugung des frischen JWT, beginnt dieselbe Sperre', async () => { + let t = 0 + const mints = [] + const brokenFresh = async (o) => { + mints.push(o?.fresh === true) + if (o?.fresh) throw new Error('429 Too Many Requests') + return 'jwt-alt' + } + const api = createWorkersApi({ getJwt: brokenFresh, fetchImpl: fakeFetch(Array.from({ length: 6 }, () => ({ status: 401, body: {} }))), now: () => t, authCooldownMs: 60000 }) + await assert.rejects(api.state(), { message: SESSION, status: 401 }) + t += 10000 + await assert.rejects(api.state(), { message: SESSION, status: 401 }) + t += 10000 + await assert.rejects(api.state(), { message: SESSION, status: 401 }) + assert.deepEqual(mints, [false, true, false, false]) // ein einziger Versuch, ein frisches JWT zu erzeugen + t += 60000 + await assert.rejects(api.state(), { message: SESSION, status: 401 }) + assert.deepEqual(mints, [false, true, false, false, false, true]) +}) + +test('401-Folge: andere Fehler (403, 500, 502) heben die Sperre auf, weil der Dienst das JWT angenommen hat', async () => { + jwts.length = 0 + let t = 0 + const api = createWorkersApi({ + getJwt, + fetchImpl: fakeFetch([{ status: 401, body: {} }, { status: 401, body: {} }, { status: 403, body: {} }, { status: 401, body: {} }, { status: 200, body: {} }]), + now: () => t, + }) + await assert.rejects(api.state(), { status: 401 }) + await assert.rejects(api.state(), { status: 403 }) + assert.deepEqual(await api.state(), {}) // 401, Wiederholung frisch ⇒ 200 + assert.deepEqual(jwts, [false, true, false, false, true]) +}) diff --git a/tests/unit/workersFeed.test.mjs b/tests/unit/workersFeed.test.mjs index 4351988..b72b902 100644 --- a/tests/unit/workersFeed.test.mjs +++ b/tests/unit/workersFeed.test.mjs @@ -6,6 +6,7 @@ import { loadModule } from './load.mjs' // Feed-Steuerung der Hustler-Seite: Zustand 15 s, Ereignisse 5 s, Cursor, Seiten, Sichtbarkeit, Fehler. // Alles mit Fake-Timern und einer Fake-API (kein Netz, keine echte Zeit). const { createFeedController } = await loadModule('src/lib/workersFeed.js') +const { createWorkersApi } = await loadModule('src/lib/workersApi.js') const nextTick = () => new Promise((resolve) => setImmediate(resolve)) @@ -396,3 +397,39 @@ test('200 Ereignisse mit demselben ts halten den Feed nicht an (Fremd-API ohne e assert.equal(new Set(all).size, all.length) assert.deepEqual(h.log.errors, []) }) + +test('hängender Abruf (tote Verbindung): die Zeitgrenze des API-Clients gibt die Schleife frei, Fehler erscheint und verschwindet wieder (Endprüfung P2)', async () => { + // Echter createWorkersApi mit kurzer Zeitgrenze, echte Timer mit kurzen Takten: der erste Zustands-Abruf kommt nie an + const state = { lastEventTs: '2026-10-17T20:00:00.000Z', workers: [] } + const urls = [] + let hungOnce = false + const fetchImpl = async (url) => { + urls.push(url) + if (url.endsWith('/state') && !hungOnce) { + hungOnce = true + return new Promise(() => {}) + } + return { ok: true, status: 200, json: async () => (url.endsWith('/state') ? state : { events: [] }) } + } + const api = createWorkersApi({ getJwt: async () => 'jwt', fetchImpl, timeoutMs: 40 }) + const snapshots = [] + const errors = [] + const c = createFeedController({ + api, + setTimer: (fn, ms) => setTimeout(fn, ms), + clearTimer: (id) => clearTimeout(id), + isVisible: () => true, + onSnapshot: (x) => snapshots.push(x), + onError: (e) => errors.push(e ? e.message : null), + stateMs: 20, + eventsMs: 20, + }) + c.start() + const until = async (ok) => { + for (let i = 0; i < 100 && !ok(); i += 1) await new Promise((r) => setTimeout(r, 20)) + } + await until(() => snapshots.length > 0) + c.stop() + assert.ok(snapshots.length >= 1, 'nach der Zeitgrenze kommt der Zustand doch noch') + assert.deepEqual(errors, ['Der Hustler-Dienst ist gerade nicht erreichbar.', null]) +})