150 lines
8.0 KiB
JavaScript
150 lines
8.0 KiB
JavaScript
// Reverse-Proxy für Dev-Previews: Host <sub>.<baseHost> ⇒ laufender Dev-Container (R5: Docker-DNS im Netz preview-sandbox).
|
|
// Keine Authentifizierung hier: die Hosts liegen hinter Traefiks preview-chain (ForwardAuth). Weitergeleitet wird
|
|
// ausschließlich an das Ziel, das dev.wake/dev.ensure liefert (preview-dev-<sub>).
|
|
import http from 'node:http';
|
|
import { isValidSub } from './validate.js';
|
|
|
|
const esc = (s) => String(s).replace(/[&<>"']/g, (c) => ({ '&': '&', '<': '<', '>': '>', '"': '"', "'": ''' }[c]));
|
|
|
|
function page(title, text, { refresh = false, hint = '' } = {}) {
|
|
return `<!doctype html><html lang="de"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">${refresh ? '<meta http-equiv="refresh" content="3">' : ''}<title>${esc(title)}</title><style>body{margin:0;min-height:100vh;display:flex;align-items:center;justify-content:center;font-family:system-ui,sans-serif;background:#f5f6f8;color:#1c2330}main{max-width:26rem;padding:2rem;text-align:center}h1{font-size:1.25rem;margin:0 0 .5rem}p{margin:.25rem 0;color:#5b6575}</style></head><body><main><h1>${esc(title)}</h1><p>${esc(text)}</p>${hint ? `<p>${esc(hint)}</p>` : ''}</main></body></html>`;
|
|
}
|
|
|
|
const PAGES = {
|
|
starting: page('Preview startet …', 'Der Dev-Server wird gestartet. Die Seite lädt automatisch neu.', { refresh: true }),
|
|
failed: page('Preview konnte nicht starten', 'Der Dev-Server ist nicht hochgekommen.', { hint: 'Details stehen im Protokoll im WOMS.' }),
|
|
unknown: page('Preview nicht verfügbar', 'Diese Preview ist gerade nicht verfügbar.'),
|
|
busy: page('Preview nicht verfügbar', 'Der Server ist gerade ausgelastet. Bitte später erneut versuchen.'),
|
|
};
|
|
|
|
function html(res, status, body, extra = {}) {
|
|
res.writeHead(status, { 'Content-Type': 'text/html; charset=utf-8', 'Content-Length': Buffer.byteLength(body), 'Cache-Control': 'no-store', ...extra });
|
|
res.end(body);
|
|
}
|
|
|
|
const HOP = ['connection', 'keep-alive', 'proxy-authorization', 'proxy-connection', 'te', 'trailer', 'transfer-encoding', 'upgrade'];
|
|
// allowHalfOpen: ein vom Client geschlossener Socket ist zwar nicht 'destroyed', aber nicht mehr lesbar
|
|
const gone = (s) => s.destroyed || !s.readable;
|
|
const TOUCH_MS = 60e3;
|
|
|
|
// Hop-by-hop-Header entfernen (samt der in Connection genannten Tokens). Auf dem Upgrade-Pfad bleiben Upgrade/Connection: Upgrade.
|
|
export function stripHop(headers, { upgrade = false } = {}) {
|
|
const out = { ...headers };
|
|
const listed = String(headers.connection || '').split(',').map((t) => t.trim().toLowerCase()).filter(Boolean);
|
|
for (const k of Object.keys(out)) if (HOP.includes(k.toLowerCase()) || listed.includes(k.toLowerCase())) delete out[k];
|
|
if (upgrade) { out.connection = 'Upgrade'; out.upgrade = headers.upgrade; }
|
|
return out;
|
|
}
|
|
|
|
export function createProxy({ config, dev, request = http.request, upstreamTimeoutMs = 120e3, now = Date.now }) {
|
|
// Sub aus dem Host-Header: exakt <sub>.<baseHost>, klein geschrieben, Port entfernt.
|
|
function subOf(hostHeader) {
|
|
const host = String(hostHeader || '').replace(/:\d+$/, '');
|
|
const suffix = `.${config.baseHost}`;
|
|
if (host !== host.toLowerCase() || !host.endsWith(suffix)) return null;
|
|
const sub = host.slice(0, -suffix.length);
|
|
return isValidSub(sub) ? sub : null;
|
|
}
|
|
|
|
function fwdHeaders(req, upgrade = false) {
|
|
const h = stripHop(req.headers, { upgrade });
|
|
const prior = req.headers['x-forwarded-for'];
|
|
const ip = req.socket.remoteAddress || '';
|
|
h['x-forwarded-for'] = prior ? `${prior}, ${ip}` : ip;
|
|
h['x-forwarded-host'] = req.headers.host || '';
|
|
h['x-forwarded-proto'] = req.headers['x-forwarded-proto'] || 'https';
|
|
return h;
|
|
}
|
|
|
|
// Ergebnis: { target } wenn online, sonst { state }.
|
|
async function resolve(sub) {
|
|
let r;
|
|
try { r = await dev.wake(sub); } catch (e) { if (e?.status !== 503) console.error('Proxy wake', sub, e); return { state: e?.status === 503 ? 'busy' : 'unknown' }; }
|
|
if (r.state === 'online' && r.target) return { target: new URL(r.target) };
|
|
return { state: r.state };
|
|
}
|
|
|
|
const server = http.createServer(async (req, res) => {
|
|
try {
|
|
const sub = subOf(req.headers.host);
|
|
if (!sub) return html(res, 404, page('Nicht gefunden', 'Diese Adresse gibt es nicht.'));
|
|
const r = await resolve(sub);
|
|
if (!r.target) {
|
|
const key = PAGES[r.state] ? r.state : 'unknown';
|
|
return html(res, 503, PAGES[key], key === 'starting' ? { 'Retry-After': '3' } : {});
|
|
}
|
|
dev.touch(sub);
|
|
const up = request({
|
|
hostname: r.target.hostname, port: r.target.port, method: req.method, path: req.url, headers: fwdHeaders(req),
|
|
}, (ures) => {
|
|
res.writeHead(ures.statusCode, stripHop(ures.headers));
|
|
ures.pipe(res);
|
|
ures.on('error', () => res.destroy());
|
|
});
|
|
let timedOut = false;
|
|
up.setTimeout(upstreamTimeoutMs, () => { timedOut = true; up.destroy(); });
|
|
up.on('error', (err) => {
|
|
if (['ECONNREFUSED', 'ENOTFOUND', 'EHOSTUNREACH', 'EAI_AGAIN'].includes(err?.code)) dev.markDead?.(sub)?.catch?.(() => {});
|
|
if (!res.headersSent) {
|
|
const body = timedOut ? 'Die Preview antwortet nicht rechtzeitig (504).' : 'Die Preview ist gerade nicht erreichbar (502).';
|
|
res.writeHead(timedOut ? 504 : 502, { 'Content-Type': 'text/plain; charset=utf-8', 'Content-Length': Buffer.byteLength(body) });
|
|
res.end(body);
|
|
} else res.destroy();
|
|
});
|
|
res.on('close', () => { if (!res.writableFinished) up.destroy(); });
|
|
req.pipe(up);
|
|
} catch (e) {
|
|
console.error('Proxy-Fehler:', e);
|
|
if (!res.headersSent) html(res, 500, page('Fehler', 'Interner Fehler.'));
|
|
else res.destroy();
|
|
}
|
|
});
|
|
|
|
server.on('upgrade', async (req, socket, head) => {
|
|
socket.on('error', () => socket.destroy());
|
|
try {
|
|
const sub = subOf(req.headers.host);
|
|
if (!sub) return socket.end('HTTP/1.1 404 Not Found\r\nConnection: close\r\n\r\n');
|
|
const r = await resolve(sub);
|
|
if (gone(socket)) return socket.destroy(); // Client hat sich während des Wartens verabschiedet
|
|
if (!r.target) return socket.end('HTTP/1.1 503 Service Unavailable\r\nConnection: close\r\n\r\n');
|
|
dev.touch(sub);
|
|
const up = request({
|
|
hostname: r.target.hostname, port: r.target.port, method: req.method, path: req.url, headers: fwdHeaders(req, true),
|
|
});
|
|
up.on('response', (ures) => { // Upstream lehnt das Upgrade ab: Antwort durchreichen und schließen
|
|
let raw = `HTTP/1.1 ${ures.statusCode} ${ures.statusMessage}\r\n`;
|
|
for (let i = 0; i < ures.rawHeaders.length; i += 2) raw += `${ures.rawHeaders[i]}: ${ures.rawHeaders[i + 1]}\r\n`;
|
|
socket.write(`${raw}\r\n`);
|
|
ures.pipe(socket);
|
|
});
|
|
up.on('upgrade', (ures, usock, uhead) => {
|
|
if (gone(socket)) { usock.destroy(); up.destroy(); return; }
|
|
usock.on('error', () => { usock.destroy(); socket.destroy(); });
|
|
// allowHalfOpen-Sockets bleiben nach 'end' offen: bei Ende oder Schließen einer Seite beide zerstören
|
|
const both = () => { usock.destroy(); socket.destroy(); };
|
|
for (const ev of ['end', 'close']) { socket.on(ev, both); usock.on(ev, both); }
|
|
let raw = `HTTP/1.1 ${ures.statusCode} ${ures.statusMessage}\r\n`;
|
|
for (let i = 0; i < ures.rawHeaders.length; i += 2) raw += `${ures.rawHeaders[i]}: ${ures.rawHeaders[i + 1]}\r\n`;
|
|
socket.write(`${raw}\r\n`);
|
|
if (uhead?.length) socket.write(uhead);
|
|
if (head?.length) usock.write(head);
|
|
// Offene Verbindung (z. B. HMR) hält den Dev-Server wach: höchstens einmal pro Minute touch
|
|
let last = now();
|
|
const keep = () => { const t = now(); if (t - last >= TOUCH_MS) { last = t; dev.touch(sub); } };
|
|
usock.on('data', keep); socket.on('data', keep);
|
|
usock.pipe(socket);
|
|
socket.pipe(usock);
|
|
});
|
|
up.on('error', () => socket.destroy());
|
|
socket.on('close', () => up.destroy());
|
|
up.end();
|
|
} catch (e) {
|
|
console.error('Proxy-Upgrade-Fehler:', e);
|
|
socket.destroy();
|
|
}
|
|
});
|
|
|
|
return server;
|
|
}
|