Der ganze Prueflauf blieb am Chat-Strom stehen -- behoben
BEFUND. Seit der Chat am 06.09. dazukam, LIEF DER GESAMTE
REGRESSIONSLAUF NICHT MEHR DURCH. Nicht "er wurde rot" -- er blieb
einfach stehen, bei Datei 3 von 62, ohne Fehlermeldung, ohne FEHL, ohne
Absturz. Nach zwoelf Minuten stand er immer noch dort. Von aussen sieht
"noch nicht fertig" genauso aus wie "haengt fuer immer"; deshalb ist
mir das gestern nicht aufgefallen, sondern erst, als ich den Lauf
gezielt beobachtet habe.
DIE URSACHE. pruef-alle-wege.mjs geht stumpf ueber ALLE 134
Schnittstellen und liest jede Antwort mit `await a.text()` aus. Der
Chat haelt seine Verbindung aber absichtlich offen und schickt neue
Nachrichten hinein, solange jemand zusieht (SSE). `text()` wartet, bis
der Server fertig ist -- und der wird nie fertig. Angemeldet als
DogFather trat der Lauf dort ein und kam nicht wieder heraus.
DIE ABHILFE, zwei Teile, die zusammengehoeren:
* Jeder Ruf hat jetzt eine Frist von 8 s. Laeuft sie ab, ist das ein
ERGEBNIS ("hing") und kein Absturz. Ein neuer Abschnitt meldet am
Ende, WELCHER Weg nicht geantwortet hat -- statt dass der Lauf
wortlos stehenbleibt.
* Bekannte Stroeme stehen in einer Liste MIT BEGRUENDUNG und werden
nicht uebersprungen, sondern anders geprueft: verbinden, Status
ablesen, abbrechen. Die Schranke wird damit genauso gemessen wie
ueberall. Zusaetzlich wird nachgemessen, dass ein eingetragener
Strom auch wirklich offen bleibt -- sonst verdeckte die Ausnahme
nur seine Inhaltspruefung.
Der "hing"-Zustand musste eigens gesammelt werden: In Abschnitt 1 haette
er ausgesehen wie "ohne Anmeldung erreichbar", in Abschnitt 2 waere er
ganz durchgefallen (`"hing" >= 500` ist false, Zeichenkette gegen Zahl).
Genau so verschwinden Befunde.
Ergebnis: 134 Schnittstellen, 532 Aufrufe, alles gruen, kein Haenger.
AUSSERDEM, gefunden beim Nachsehen:
* pruef-handy.mjs pruefte 15 Seiten -- aus einer Liste von Hand, die
veraltet war. chat.html, leistung.html und steckbrief.html standen
nicht darin: DREI von neunzehn Seiten waren nie auf einem Handy
gemessen worden, ausgerechnet der Chat. Die Liste kommt jetzt aus
dem Verzeichnis, die naechste neue Seite ist von selbst dabei.
* chat.html und leistung.html fehlte <link rel="manifest">. Auf dem
Handy heisst das: Wer die App installiert hat und ueber eine
Benachrichtigung dort landet, verlaesst den App-Rahmen -- die Seite
oeffnet im Browser, mit falscher Leistenfarbe. Ihre theme-color war
ausserdem eine andere als auf allen uebrigen Seiten. Beides behoben
UND als Pruefung in pruef-struktur nachgetragen, damit es beim
naechsten Mal nicht am Gedaechtnis haengt.
NEU: tools/wiederherstellung-proben.mjs — die Probe aufs Exempel.
Die Sicherung ausserhalb des Servers laeuft taeglich und prueft
`integrity_check`. Das sagt: die Datei ist nicht zerschossen. Es sagt
NICHT, ob die Anwendung damit startet, ob man sich anmelden kann und ob
die Daten vollstaendig sind. Eine Sicherung, die man nie zurueckgespielt
hat, ist eine Hoffnung. Das Werkzeug kopiert die juengste Sicherung in
ein Wegwerf-Verzeichnis, startet die echte Anwendung dagegen (damit
laufen alle Schemawanderungen wirklich durch), zaehlt vorher und
nachher, meldet sich an und ruft jede Seite auf. Drei Ausgaenge, nicht
zwei -- "konnte nicht nachsehen" ist weder Erfolg noch Fehler.
Co-Authored-By: Claude Opus 5 <[email protected]>
This commit is contained in:
Claude Opus 5
+120
-4
@@ -200,6 +200,49 @@ function nummerFuer(pfad) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* ---------- WEGE, DIE NIE ZU ENDE ANTWORTEN ------------------------------
|
||||
|
||||
Der Chat haelt seit dem 06.09.2026 eine Verbindung offen und schickt
|
||||
darueber Nachrichten, sobald sie entstehen (Server-Sent Events). Das
|
||||
ist genau der Zweck -- und fuer diese Pruefung eine Falle: `a.text()`
|
||||
wartet, bis der Server fertig ist, und der wird nie fertig.
|
||||
|
||||
GEMESSEN, NICHT VERMUTET: Der komplette Prueflauf blieb dadurch
|
||||
haengen. Angemeldet als DogFather trat er in /workspace/api/chat/strom
|
||||
ein und kam nicht wieder heraus -- nach zwoelf Minuten war er immer
|
||||
noch dort. Es lief kein Fehler auf, es stand kein FEHL da: Der ganze
|
||||
Regressionslauf hoerte einfach auf, weiterzugehen. Das ist die
|
||||
unangenehmste Sorte, weil "noch nicht fertig" und "haengt fuer immer"
|
||||
von aussen gleich aussehen.
|
||||
|
||||
ZWEI DINGE dagegen, und beide gehoeren zusammen:
|
||||
|
||||
1. JEDER Ruf bekommt eine Frist. Laeuft sie ab, ist das ein
|
||||
ERGEBNIS ("hing") und kein Absturz -- die Pruefung laeuft weiter
|
||||
und sagt am Ende, wo es klemmte.
|
||||
2. Bekannte Stroeme stehen hier mit Begruendung. Sie werden nicht
|
||||
uebersprungen (ein uebersprungener Test beweist nichts), sondern
|
||||
ANDERS geprueft: verbinden, den Status ablesen, abbrechen. Die
|
||||
Schranke wird damit genauso gemessen wie ueberall sonst.
|
||||
|
||||
Wer einen weiteren Strom baut, traegt ihn hier ein. Vergisst er es,
|
||||
haengt der Lauf -- und die Frist macht daraus eine Meldung mit
|
||||
Dateinamen statt eines stillen Stillstands. */
|
||||
const STROEME = new Map([
|
||||
["/workspace/api/chat/strom",
|
||||
"haelt die Verbindung offen und schickt neue Nachrichten sofort (SSE)"],
|
||||
]);
|
||||
|
||||
const FRIST_MS = 8000;
|
||||
|
||||
/* Jeder Weg, der nicht antwortet, landet hier -- und wird am Ende
|
||||
EINMAL gemeldet. Ihn an Ort und Stelle in die jeweilige Liste zu
|
||||
werfen waere falsch: In Abschnitt 1 saehe er aus wie "ohne Anmeldung
|
||||
erreichbar", in Abschnitt 2 fiele er ganz durch (`"hing" >= 500` ist
|
||||
false, weil Zeichenkette gegen Zahl immer false ergibt). Genau so
|
||||
verschwinden Befunde. */
|
||||
const HAENGER = [];
|
||||
|
||||
async function ruf(art, pfad, keks) {
|
||||
const kopf = { "Content-Type": "application/json", origin: BASIS };
|
||||
if (keks) kopf.cookie = keks;
|
||||
@@ -210,10 +253,37 @@ async function ruf(art, pfad, keks) {
|
||||
start: heute, uhrzeit: "10:00", rolle: "creator", ziele: "Ziel",
|
||||
nachricht: "Hallo", schluessel: "technik-01", erledigt: true,
|
||||
});
|
||||
const a = await fetch(BASIS + pfad, { method: art, headers: kopf, body: rumpf, redirect: "manual" });
|
||||
let text = "";
|
||||
try { text = await a.text(); } catch { /* egal */ }
|
||||
return { status: a.status, text };
|
||||
|
||||
const abbruch = new AbortController();
|
||||
const wecker = setTimeout(() => abbruch.abort(), FRIST_MS);
|
||||
try {
|
||||
const a = await fetch(BASIS + pfad, {
|
||||
method: art, headers: kopf, body: rumpf, redirect: "manual", signal: abbruch.signal,
|
||||
});
|
||||
/* Ein Strom liefert den Status sofort und den Rumpf nie. Der Status
|
||||
ist das, worauf es hier ankommt -- also wird er gelesen und die
|
||||
Verbindung danach zugemacht. */
|
||||
if (STROEME.has(pfad)) {
|
||||
abbruch.abort();
|
||||
return { status: a.status, text: "(Strom, Rumpf nicht gelesen)" };
|
||||
}
|
||||
let text = "";
|
||||
try { text = await a.text(); } catch { /* egal */ }
|
||||
return { status: a.status, text };
|
||||
} catch (f) {
|
||||
if (f?.name === "AbortError") {
|
||||
/* HAENGT. Als eigener Zustand, nicht als 0 und nicht als Absturz:
|
||||
Ein Weg, der nicht antwortet, ist etwas anderes als einer, der
|
||||
mit einem Fehler antwortet -- und etwas ganz anderes als einer,
|
||||
der in Ordnung ist. */
|
||||
HAENGER.push(`${art} ${pfad}${keks ? " (angemeldet)" : ""}`);
|
||||
return { status: "hing", text: `keine Antwort binnen ${FRIST_MS} ms` };
|
||||
}
|
||||
HAENGER.push(`${art} ${pfad} — ${String(f?.message || f).slice(0, 60)}`);
|
||||
return { status: "fehler", text: String(f?.message || f).slice(0, 80) };
|
||||
} finally {
|
||||
clearTimeout(wecker);
|
||||
}
|
||||
}
|
||||
|
||||
/* =======================================================================
|
||||
@@ -343,6 +413,52 @@ ok(ohneSchranke.length === 0,
|
||||
? `OHNE HERKUNFTSPRUEFUNG:\n ` + ohneSchranke.slice(0, 10).join("\n ")
|
||||
: "kein schreibender Weg nimmt eine fremde Herkunft an");
|
||||
|
||||
/* =======================================================================
|
||||
5. Hat irgendein Weg gar nicht geantwortet?
|
||||
======================================================================= */
|
||||
console.log(`\n=== Antwortet jeder Weg ueberhaupt? ===`);
|
||||
ok(HAENGER.length === 0,
|
||||
HAENGER.length
|
||||
? `${HAENGER.length} Aufrufe blieben ohne Antwort — das ist der Grund, wenn der `
|
||||
+ `Gesamtlauf stehenbleibt:\n ` + [...new Set(HAENGER)].slice(0, 8).join("\n ")
|
||||
+ `\n Ist es ein Ereignisstrom, gehoert er in STROEME (oben, mit Begruendung).`
|
||||
: `alle Aufrufe kamen binnen ${FRIST_MS} ms zurueck`);
|
||||
|
||||
/* Und die Sonderbehandlung selbst muss stimmen: Ein Strom, der auf
|
||||
einmal doch einen fertigen Rumpf liefert, ist keiner mehr -- dann
|
||||
gehoert er aus der Liste heraus, sonst wird sein Inhalt nie geprueft.
|
||||
Und ein Weg, den ich faelschlich als Strom eintrage, verlaere still
|
||||
seine Inhaltspruefung. Deshalb wird beides nachgemessen. */
|
||||
{
|
||||
let belegt = 0;
|
||||
for (const [pfad, grund] of STROEME) {
|
||||
const bekannt = ROUTEN.some((r) => r.pfad === pfad);
|
||||
if (!bekannt) {
|
||||
ok(false, `${pfad} steht in STROEME, ist aber gar keine Route mehr — Eintrag entfernen`);
|
||||
continue;
|
||||
}
|
||||
/* Der Strom muss WIRKLICH offen bleiben. Wenn er von selbst endet,
|
||||
ist die Ausnahme unnoetig und verdeckt nur seinen Inhalt. */
|
||||
const abbruch = new AbortController();
|
||||
const wecker = setTimeout(() => abbruch.abort(), 2500);
|
||||
let endeteVonSelbst = false;
|
||||
let status = null;
|
||||
try {
|
||||
const a = await fetch(BASIS + pfad, {
|
||||
headers: { cookie: KEKSE.admin }, signal: abbruch.signal,
|
||||
});
|
||||
status = a.status;
|
||||
await a.text();
|
||||
endeteVonSelbst = true;
|
||||
} catch { /* abgebrochen = er blieb offen, wie es sein soll */ }
|
||||
clearTimeout(wecker);
|
||||
belegt++;
|
||||
ok(status === 200 && !endeteVonSelbst,
|
||||
`${pfad} liefert angemeldet ${status} und bleibt offen — ${grund}`);
|
||||
}
|
||||
ok(belegt === STROEME.size, `alle ${STROEME.size} eingetragenen Stroeme nachgemessen`);
|
||||
}
|
||||
|
||||
/* =======================================================================
|
||||
GEGENPROBE — findet diese Pruefung ueberhaupt etwas?
|
||||
======================================================================= */
|
||||
|
||||
+51
-5
@@ -106,11 +106,57 @@ const { chromium } = await import(
|
||||
"file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs");
|
||||
const browser = await chromium.launch();
|
||||
|
||||
const SEITEN = [
|
||||
"start.html", "uebersicht.html", "aufgaben.html", "kalender.html", "personen.html",
|
||||
"profil.html", "wissen.html", "dateien.html", "calls.html", "startcheck.html",
|
||||
"report.html", "scouting.html", "automation.html", "content.html", "bereich.html?b=live",
|
||||
];
|
||||
/* ---------- WELCHE SEITEN? ALLE. -----------------------------------------
|
||||
|
||||
Hier stand bis zum 06.09.2026 eine Liste von Hand -- und sie war
|
||||
veraltet, ohne dass es jemandem auffiel: chat.html, leistung.html und
|
||||
steckbrief.html fehlten darin, also DREI von neunzehn Seiten waren nie
|
||||
auf einem Handy gemessen worden. Der Chat ausgerechnet ist die Seite,
|
||||
die man am ehesten unterwegs benutzt.
|
||||
|
||||
Das ist genau die Sorte Fehler, die eine Liste macht: Sie altert in
|
||||
dem Moment, in dem jemand weiterarbeitet, und sie sagt nichts dazu.
|
||||
Der Lauf blieb gruen, die Zahl der Pruefungen stimmte -- gemessen
|
||||
wurde trotzdem zu wenig.
|
||||
|
||||
Deshalb wird die Liste jetzt aus dem VERZEICHNIS gelesen. Eine neue
|
||||
Seite ist damit von selbst dabei, so wie sie durch die Schranke in
|
||||
workspace.js von selbst geschuetzt ist -- derselbe Gedanke: Der
|
||||
sichere Rueckfall muss der VORGABEwert sein, nicht der, an den man
|
||||
denken muss.
|
||||
|
||||
Ausgenommen ist einzig index.html -- das ist die Anmeldeseite, sie
|
||||
wird weiter unten eigens geprueft (vor der Anmeldung, denn danach
|
||||
leitet sie weiter). */
|
||||
const { readdirSync } = await import("node:fs");
|
||||
const { dirname } = await import("node:path");
|
||||
const { fileURLToPath } = await import("node:url");
|
||||
/* NICHT process.cwd(): Diese Datei wird mal aus dem Wurzelverzeichnis
|
||||
gestartet (tools/alles-pruefen.mjs) und mal aus server/ von Hand. Im
|
||||
zweiten Fall zeigte cwd auf server/, dort gibt es kein workspace/,
|
||||
und readdirSync wuerfe -- oder faende, schlimmer, ein anderes
|
||||
Verzeichnis. Der Ort DIESER Datei steht dagegen fest. */
|
||||
const SEITEN_ORDNER = join(dirname(fileURLToPath(import.meta.url)), "..", "workspace");
|
||||
const ALLE_SEITEN = readdirSync(SEITEN_ORDNER)
|
||||
.filter((n) => n.endsWith(".html") && n !== "index.html")
|
||||
.sort();
|
||||
|
||||
/* Ein paar Seiten brauchen eine Abfrage, sonst zeigen sie nur ihre
|
||||
leere Huelle. Fuer die steht hier, WOMIT sie aufgerufen werden. */
|
||||
const MIT_ABFRAGE = { "bereich.html": "?b=live" };
|
||||
const SEITEN = ALLE_SEITEN.map((n) => n + (MIT_ABFRAGE[n] || ""));
|
||||
|
||||
/* Und die Zahl gehoert in die BEDINGUNG, nicht nur in den Meldetext:
|
||||
Faende readdirSync nichts (falsches Arbeitsverzeichnis), liefe die
|
||||
Schleife unten null Mal -- und der Lauf waere gruen, ohne eine
|
||||
einzige Seite angesehen zu haben. Genau der Fehler, den ich schon
|
||||
zweimal hatte. */
|
||||
if (SEITEN.length < 15) {
|
||||
console.log(` FEHL nur ${SEITEN.length} Seiten in ${SEITEN_ORDNER} gefunden `
|
||||
+ "-- die Handypruefung kann so nichts messen");
|
||||
process.exit(1);
|
||||
}
|
||||
console.log(`${SEITEN.length} Workspace-Seiten werden gemessen: ${SEITEN.join(", ")}`);
|
||||
|
||||
/* Drei echte Geraete, nicht "irgendwas Schmales":
|
||||
320 iPhone SE (1. Gen) -- das schmalste noch benutzte Geraet
|
||||
|
||||
@@ -398,6 +398,41 @@ console.log(`
|
||||
ok(ohneApple.length === 0,
|
||||
ohneApple.length ? `ohne apple-touch-icon (iPhone nimmt sonst einen Screenshot): ${ohneApple.join(", ")}`
|
||||
: `alle ${seiten.length} Workspace-Seiten nennen ein iPhone-Symbol`);
|
||||
|
||||
/* UND DAS MANIFEST (06.09.2026 nachgetragen).
|
||||
|
||||
Gefunden, weil ich es selbst zweimal vergessen habe: chat.html und
|
||||
leistung.html -- die beiden neuesten Seiten -- hatten kein
|
||||
<link rel="manifest">. Folge auf dem Handy: Wer die Anwendung
|
||||
installiert hat und ueber eine Benachrichtigung auf einer dieser
|
||||
Seiten landet, verlaesst damit den App-Rahmen. Die Seite oeffnet
|
||||
in der Adressleiste des Browsers statt in der App, mit falscher
|
||||
Leistenfarbe und ohne Zurueckweg in den Rest.
|
||||
|
||||
Es faellt niemandem auf, weil am Rechner alles normal aussieht.
|
||||
Genau darum steht es jetzt hier: Was man beim Anlegen einer neuen
|
||||
Seite vergessen kann, muss eine Pruefung nachhalten -- nicht das
|
||||
Gedaechtnis. Und weil `seiten` aus dem Verzeichnis kommt, ist die
|
||||
naechste neue Seite von selbst dabei.
|
||||
|
||||
theme-color gehoert dazu: Ohne sie zeichnet Android die
|
||||
Systemleiste weiss -- ein greller Balken ueber einer dunklen
|
||||
Oberflaeche, das Gegenteil von augenschonend. */
|
||||
const ohneManifest = [];
|
||||
const ohneFarbe = [];
|
||||
for (const seite of seiten) {
|
||||
const text = readFileSync(join(WS, seite), "utf8");
|
||||
if (!/rel="manifest"/i.test(text)) ohneManifest.push(seite);
|
||||
if (!/name="theme-color"/i.test(text)) ohneFarbe.push(seite);
|
||||
}
|
||||
ok(seiten.length > 10 && ohneManifest.length === 0,
|
||||
ohneManifest.length
|
||||
? `ohne <link rel="manifest"> — oeffnet auf dem Handy ausserhalb der App: ${ohneManifest.join(", ")}`
|
||||
: `alle ${seiten.length} Seiten binden das Manifest ein`);
|
||||
ok(seiten.length > 10 && ohneFarbe.length === 0,
|
||||
ohneFarbe.length
|
||||
? `ohne theme-color — Android zeichnet die Leiste dann weiss: ${ohneFarbe.join(", ")}`
|
||||
: `alle ${seiten.length} Seiten setzen eine theme-color`);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user