@w-lfpup/jackrabbit 0.2.0 → 0.3.1

package/webdriver/dist/routes.js

@@ -0,0 +1,162 @@
+import * as fs from "fs";
+import * as path from "path";
+import { testHanger } from "./test_hangar.js";
+let cwd = process.cwd();
+const parentPath = path.join(import.meta.url.substring(5), "../../../");
+const MIME_TYPES = {
+    octet: "application/octet-stream",
+    html: "text/html; charset=UTF-8",
+    js: "text/javascript",
+    json: "application/json",
+    css: "text/css",
+    png: "image/png",
+    jpg: "image/jpeg",
+    ico: "image/x-icon",
+    svg: "image/svg+xml",
+};
+export class Router {
+    #config;
+    #eventbus;
+    constructor(config, eventbus) {
+        this.#config = config;
+        this.#eventbus = eventbus;
+    }
+    get route() {
+        return this.#boundRoute;
+    }
+    #boundRoute = this.#route.bind(this);
+    async #route(req, res) {
+        if (serveBadRequest(req, res))
+            return;
+        if (servePing(req, res))
+            return;
+        if (serveTestPage(req, res, this.#config))
+            return;
+        if (logAction(req, res, this.#eventbus))
+            return;
+        await serveFile(req, res);
+    }
+}
+function serveBadRequest(req, res) {
+    let { url } = req;
+    if (url)
+        return false;
+    res.setHeader("Content-Type", "text/html");
+    res.writeHead(400);
+    res.end();
+    return true;
+}
+function servePing(req, res) {
+    let { url, method } = req;
+    if (url !== "/ping" || "GET" !== method)
+        return false;
+    res.setHeader("Content-Type", "text/html");
+    res.writeHead(200);
+    res.end("The cookie train has arrived!");
+    return true;
+}
+function serveTestPage(req, res, config) {
+    let { url, method } = req;
+    if (url !== "/" || "GET" !== method)
+        return false;
+    let hangar = testHanger({
+        jackrabbit_url: config.hostAndPort,
+        test_collections: process.argv.slice(3),
+    });
+    res.setHeader("Content-Type", "text/html");
+    res.writeHead(200);
+    res.end(hangar);
+    return true;
+}
+function logAction(req, res, eventbus) {
+    let { url, method } = req;
+    if (!url?.startsWith("/log/") || "POST" !== method)
+        return false;
+    let id;
+    let cookies = req.headers.cookie?.split(";") ?? [];
+    for (const cookieLine of cookies) {
+        if (cookieLine.startsWith("jackrabbit=")) {
+            let [_name, value] = cookieLine.split("=");
+            id = value;
+        }
+    }
+    if (id) {
+        getLoggerActionFromRequestBody(req)
+            .then(function (loggerAction) {
+            eventbus.dispatchAction({
+                type: "log",
+                loggerAction,
+                id,
+            });
+            res.writeHead(201);
+        })
+            .catch(function () {
+            res.writeHead(401);
+        })
+            .finally(function () {
+            res.end();
+        });
+    }
+    else {
+        res.writeHead(401);
+        res.end();
+    }
+    return true;
+}
+async function serveFile(req, res) {
+    let { url, method } = req;
+    if (!url || "GET" !== method) {
+        res.setHeader("Content-Type", MIME_TYPES["html"]);
+        res.writeHead(400);
+        res.end();
+        return;
+    }
+    let urlFilePath = path.join(url);
+    let extStr = "";
+    if (url.endsWith("/"))
+        extStr = "index.html";
+    let urlNoPrefix = url;
+    if (urlFilePath.startsWith("/jackrabbit")) {
+        let strippedUrl = urlFilePath.substring("/jackrabbit".length);
+        urlFilePath = path.join(parentPath, strippedUrl, extStr);
+    }
+    else {
+        urlFilePath = path.join(cwd, urlNoPrefix, extStr);
+    }
+    let stream = await getFile(urlFilePath);
+    if (stream) {
+        const ext = path.extname(urlFilePath).substring(1).toLowerCase();
+        let mimeType = MIME_TYPES[ext] ?? MIME_TYPES["octet"];
+        res.setHeader("Content-Type", mimeType);
+        res.writeHead(200);
+        stream.pipe(res);
+    }
+    else {
+        res.setHeader("Content-Type", MIME_TYPES["html"]);
+        res.writeHead(404);
+        res.end();
+    }
+}
+function getLoggerActionFromRequestBody(req) {
+    return new Promise(function (resolve, reject) {
+        let data = [];
+        req.addListener("data", function (chunk) {
+            data.push(chunk);
+        });
+        req.addListener("end", function () {
+            let actionStr = Buffer.concat(data).toString();
+            let action = JSON.parse(actionStr);
+            resolve(action);
+        });
+        req.addListener("error", function (err) {
+            reject(err);
+        });
+    });
+}
+async function getFile(filePath) {
+    try {
+        await fs.promises.access(filePath);
+        return fs.createReadStream(filePath);
+    }
+    catch { }
+}

package/webdriver/dist/routes2.js

@@ -0,0 +1,163 @@
+import * as fs from "fs";
+import * as path from "path";
+import { testHanger } from "./test_hangar.js";
+let cwd = process.cwd();
+// better done with URL? feels weird
+let corePath = path.join(import.meta.url.substring(5), "../../../core/dist/");
+let browserPath = path.join(import.meta.url.substring(5), "../../../browser/dist/");
+const MIME_TYPES = {
+    octet: "application/octet-stream",
+    html: "text/html; charset=UTF-8",
+    js: "text/javascript",
+    json: "application/json",
+    css: "text/css",
+    png: "image/png",
+    jpg: "image/jpeg",
+    ico: "image/x-icon",
+    svg: "image/svg+xml",
+};
+export class Router {
+    #config;
+    #eventbus;
+    constructor(config, eventbus) {
+        this.#config = config;
+        this.#eventbus = eventbus;
+    }
+    get route() {
+        return this.#boundRoute;
+    }
+    #boundRoute = this.#route.bind(this);
+    async #route(req, res) {
+        if (serveBadRequest(req, res))
+            return;
+        if (servePing(req, res))
+            return;
+        if (serveTestPage(req, res, this.#config))
+            return;
+        if (logAction(req, res, this.#eventbus))
+            return;
+        await serveFile(req, res);
+    }
+}
+function getLoggerActionFromRequestBody(req) {
+    return new Promise(function (resolve, reject) {
+        let data = [];
+        req.addListener("data", function (chunk) {
+            data.push(chunk);
+        });
+        req.addListener("end", function () {
+            let actionStr = Buffer.concat(data).toString();
+            let action = JSON.parse(actionStr);
+            resolve(action);
+        });
+        req.addListener("error", function (err) {
+            reject(err);
+        });
+    });
+}
+async function getDirectoryScopedFile(filePath, basePath) {
+    if (!filePath.startsWith(basePath))
+        return;
+    try {
+        await fs.promises.access(filePath);
+        return fs.createReadStream(filePath);
+    }
+    catch { }
+}
+function serveBadRequest(req, res) {
+    let { url } = req;
+    if (url)
+        return false;
+    res.setHeader("Content-Type", "text/html");
+    res.writeHead(400);
+    res.end();
+    return true;
+}
+function servePing(req, res) {
+    let { url, method } = req;
+    if (url !== "/ping" || "GET" !== method)
+        return false;
+    res.setHeader("Content-Type", "text/html");
+    res.writeHead(200);
+    res.end("The cookie train has arrived!");
+    return true;
+}
+function serveTestPage(req, res, config) {
+    let { url, method } = req;
+    if (url !== "/" || "GET" !== method)
+        return false;
+    let hangar = testHanger({
+        jackrabbit_url: config.hostAndPort,
+        test_collections: process.argv.slice(3),
+    });
+    res.setHeader("Content-Type", "text/html");
+    res.writeHead(200);
+    res.end(hangar);
+    return true;
+}
+function logAction(req, res, eventbus) {
+    let { url, method } = req;
+    if (url?.startsWith("/log/") && "POST" === method)
+        return false;
+    let id;
+    let cookies = req.headers.cookie?.split(";") ?? [];
+    for (const cookieLine of cookies) {
+        if (cookieLine.startsWith("jackrabbit=")) {
+            let [_name, value] = cookieLine.split("=");
+            id = value;
+        }
+    }
+    if (!id)
+        return false;
+    getLoggerActionFromRequestBody(req)
+        .then(function (loggerAction) {
+        eventbus.dispatchAction({
+            type: "log",
+            loggerAction,
+            id,
+        });
+        res.writeHead(200);
+    })
+        .catch(function () {
+        res.writeHead(403);
+    })
+        .finally(function () {
+        res.end();
+    });
+    return true;
+}
+async function serveFile(req, res) {
+    let { url, method } = req;
+    if (!url)
+        return;
+    let ext = "";
+    if (url.endsWith("/"))
+        ext = "index.html";
+    let urlNoPrefix = url;
+    if (url.startsWith("/jackrabbit"))
+        urlNoPrefix = url.substring(11);
+    let filePath = path.join(cwd, urlNoPrefix, ext);
+    let stream;
+    if (url.startsWith("/jackrabbit/core/") && "GET" === method) {
+        stream = await getDirectoryScopedFile(filePath, corePath);
+    }
+    if (url.startsWith("/jackrabbit/browser/") && "GET" === method) {
+        stream = await getDirectoryScopedFile(filePath, browserPath);
+    }
+    if (!url.startsWith("/jackrabbit") && "GET" === method) {
+        stream = await getDirectoryScopedFile(filePath, cwd);
+    }
+    if (stream) {
+        // throwing errors and stuff
+        const ext = path.extname(filePath).substring(1).toLowerCase();
+        let mimeType = MIME_TYPES[ext] ?? MIME_TYPES["octet"];
+        res.setHeader("Content-Type", mimeType);
+        res.writeHead(200);
+        stream.pipe(res);
+    }
+    else {
+        res.setHeader("Content-Type", MIME_TYPES["html"]);
+        res.writeHead(404);
+        res.end();
+    }
+}

package/webdriver/dist/test_hangar.js

@@ -0,0 +1,20 @@
+export function testHanger(params) {
+    return `<!DOCTYPE html>
+<html>
+	<head>
+		<script type="jackrabbit_config">
+			${JSON.stringify(params)}
+		</script>
+		<script type="importmap">
+			{
+				"imports": {
+					"jackrabbit/core/": "/jackrabbit/core/"
+				}
+			}
+		</script>
+		<script type="module" src="/jackrabbit/browser/dist/mod.js"></script>
+	</head>
+	<body></body>
+</html>
+`;
+}

package/webdriver/dist/webdriver.js

@@ -0,0 +1,272 @@
+import { exec } from "child_process";
+let headers = new Headers([["Content-Type", "application/json"]]);
+export class WebDrivers {
+    #config;
+    #eventbus;
+    #webdrivers = [];
+    #currentIndex = 0;
+    constructor(config, eventbus) {
+        this.#eventbus = eventbus;
+        this.#config = config;
+        for (const params of config.webdrivers) {
+            this.#webdrivers.push(new WebdriverSession(params, config.hostAndPort, eventbus));
+        }
+    }
+    run() {
+        this.#eventbus.addListener("session_closed", (action) => {
+            if (action.id !== this.#config.webdrivers[this.#currentIndex]?.jrId)
+                return;
+            this.#currentIndex += 1;
+            let webdriver = this.#webdrivers[this.#currentIndex];
+            webdriver
+                ? webdriver.run()
+                : this.#eventbus.dispatchAction({
+                    type: "end",
+                });
+        });
+        let webdriver = this.#webdrivers[this.#currentIndex];
+        webdriver
+            ? webdriver.run()
+            : this.#eventbus.dispatchAction({
+                type: "end",
+            });
+    }
+    runAll() {
+        this.#eventbus.addListener("session_closed", (action) => {
+            let { id } = action;
+            let [indexStr] = id.split(":");
+            let index = parseInt(indexStr);
+            if (this.#webdrivers[index]) {
+                if (id === this.#config.webdrivers[index]?.jrId)
+                    this.#currentIndex += 1;
+            }
+            if (this.#currentIndex === this.#webdrivers.length) {
+                this.#eventbus.dispatchAction({
+                    type: "end",
+                });
+            }
+        });
+        for (let webdriver of this.#webdrivers) {
+            webdriver.run();
+        }
+    }
+}
+class WebdriverSession {
+    #params;
+    #hostAndPort;
+    #eventbus;
+    #process;
+    #signal;
+    #abortController;
+    #sessionId;
+    constructor(params, hostAndPort, eventbus) {
+        this.#params = params;
+        this.#hostAndPort = hostAndPort;
+        this.#eventbus = eventbus;
+        this.#abortController = new AbortController();
+        this.#eventbus.addListener("run_complete", (action) => {
+            if (action.id === this.#params.jrId)
+                this.#down();
+        });
+    }
+    async run() {
+        if (this.#process)
+            return;
+        let { jrId } = this.#params;
+        this.#eventbus.dispatchAction({
+            id: jrId,
+            type: "session_start",
+        });
+        this.#signal = setupSignal(this.#params, this.#eventbus, this.#abortController.signal);
+        this.#process = setupProcess(this.#params, this.#eventbus, this.#abortController.signal);
+        try {
+            await untilWebdriverReady(this.#params, this.#signal);
+            this.#sessionId = await getSession(this.#params, this.#signal);
+            await goToPing(this.#params, this.#signal, this.#sessionId, this.#hostAndPort);
+            await setCookie(this.#params, this.#signal, this.#sessionId);
+            await goToTestPage(this.#params, this.#signal, this.#sessionId, this.#hostAndPort);
+        }
+        catch (e) {
+            let errOutput;
+            if (e instanceof Error) {
+                errOutput = e.name + "\n" + e.message + (e.cause ? "\n" + e.cause : "");
+            }
+            if (!errOutput)
+                errOutput = e?.toString();
+            this.#eventbus.dispatchAction({
+                type: "session_error",
+                id: this.#params.jrId,
+                error: errOutput ?? "Unknown error creating browser session",
+            });
+            this.#abortController.abort();
+        }
+    }
+    async #down() {
+        if (!this.#process)
+            return;
+        await deleteSession(this.#params, this.#signal, this.#eventbus, this.#sessionId);
+        this.#process.kill();
+        this.#process = undefined;
+    }
+}
+function setupSignal(params, eventbus, externalSignal) {
+    let { jrId, timeoutMs } = params;
+    let signal = AbortSignal.any([
+        externalSignal,
+        AbortSignal.timeout(timeoutMs),
+    ]);
+    signal.addEventListener("abort", function () {
+        eventbus.dispatchAction({
+            type: "session_closed",
+            id: jrId,
+        });
+    });
+    return signal;
+}
+function setupProcess(params, eventbus, externalSignal) {
+    let { command, jrId } = params;
+    let process = exec(command, { signal: externalSignal }, (error, _stdout, stderr) => {
+        if (stderr) {
+            eventbus.dispatchAction({
+                id: jrId,
+                type: "stderr",
+                output: stderr,
+            });
+        }
+    });
+    process.addListener("error", function (error) {
+        eventbus.dispatchAction({
+            id: jrId,
+            type: "session_error",
+            error: error.toString(),
+        });
+    });
+    process.addListener("exit", function (statusCode) {
+        if (statusCode) {
+            eventbus.dispatchAction({
+                type: "session_error",
+                id: jrId,
+                error: `Process returned status code: ${statusCode}`,
+            });
+        }
+        eventbus.dispatchAction({
+            type: "session_closed",
+            id: jrId,
+        });
+    });
+    return process;
+}
+async function untilWebdriverReady(params, signal) {
+    let { url } = params;
+    while (signal && !signal.aborted) {
+        try {
+            let res = await fetch(new URL("/status", url), {
+                method: "GET",
+                headers,
+                body: null,
+                signal,
+            });
+            if (200 === res.status) {
+                let json = await res.json();
+                let { ready } = json?.value;
+                if (typeof ready === "boolean" && ready)
+                    return;
+            }
+        }
+        catch { }
+        await sleep(30);
+    }
+    throw new Error("Webdriver was never ready.");
+}
+async function getSession(params, signal) {
+    let { url, capabilities } = params;
+    let res = await fetch(new URL("/session", url), {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ capabilities: capabilities ?? {} }),
+        signal,
+    });
+    if (200 !== res.status) {
+        let cause = await res.text();
+        throw new Error("Failed to create a session", { cause });
+    }
+    let json = await res.json();
+    let { sessionId } = json?.value;
+    if (typeof sessionId !== "string")
+        throw new Error("session is not a string");
+    return sessionId;
+}
+async function goToPing(params, signal, sessionId, hostAndPort) {
+    let { url } = params;
+    let pingUrl = new URL("/ping", hostAndPort);
+    let getCookie = await fetch(new URL(`/session/${sessionId}/url`, url), {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ url: pingUrl }),
+        signal,
+    });
+    if (200 !== getCookie.status) {
+        let cause = await getCookie.json();
+        throw new Error("go-to-cookie request failed", { cause });
+    }
+}
+async function setCookie(params, signal, sessionId) {
+    let { url, jrId } = params;
+    let cookieReq = await fetch(new URL(`/session/${sessionId}/cookie`, url), {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+            cookie: {
+                name: "jackrabbit",
+                value: jrId,
+                path: "/",
+                httpOnly: true,
+            },
+        }),
+        signal,
+    });
+    if (200 !== cookieReq.status) {
+        let cause = await cookieReq.json();
+        throw new Error("set-cookie request failed", { cause });
+    }
+}
+async function goToTestPage(params, signal, sessionId, hostAndPort) {
+    let { url } = params;
+    let goToUrlRes = await fetch(new URL(`/session/${sessionId}/url`, url), {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ url: hostAndPort }),
+        signal,
+    });
+    if (200 !== goToUrlRes.status)
+        throw new Error("go-to-url request failed");
+}
+async function deleteSession(params, signal, eventbus, sessionId) {
+    let { url } = params;
+    try {
+        let delReqest = await fetch(new URL(`/session/${sessionId}`, url), {
+            method: "DELETE",
+            headers,
+            body: null,
+            signal: signal,
+        });
+        if (200 !== delReqest.status) {
+            let cause = await delReqest.json();
+            throw new Error("delete-cookie request failed", { cause });
+        }
+    }
+    catch (e) {
+        eventbus.dispatchAction({
+            type: "session_error",
+            id: params.jrId,
+            error: e?.toString() ?? "failed to delete browser session error",
+        });
+    }
+}
+function sleep(timeMs) {
+    return new Promise(function (resolve) {
+        setTimeout(function () {
+            resolve();
+        }, timeMs);
+    });
+}

package/webdriver/package.json

@@ -0,0 +1,8 @@
+{
+	"name": "webdriver",
+	"type": "module",
+	"main": "dist/mod.js",
+	"scripts": {
+		"build": "npx tsc --build"
+	}
+}