check.ts

import { delay } from "https://deno.land/std@0.224.0/async/mod.ts";
import { Spinner } from "https://deno.land/std@0.218.0/cli/spinner.ts";

const localBaseUrl = "http://localhost:12345/";

const serverHealthCheck = async () => {
  const loginURL = new URL("/login", localBaseUrl);
  while (true) {
    try {
      const cookies = (await fetch(loginURL, { method: "post" })).headers
        .getSetCookie();
      if (cookies.length > 0) {
        // Healthcheck OK!
        return true;
      }
    } catch (_) {
      // Try again
    }

    await delay(1000);
  }
};

const startServer = async (checkDir: string) => {
  const dockerUp = new Deno.Command("docker", {
    args: ["compose", "up", "--build"],
    cwd: checkDir,
  });

  // Wait until the server starts up...
  const spinner = new Spinner({ message: "Starting server..." });
  spinner.start();

  const timeout = new Promise((resolve) => {
    // Timeout = 10min
    setTimeout(resolve, 600 * 1000, false);
  });
  const dockerKilled = async () => {
    await dockerUp.output();
    return false;
  };
  const success = await Promise.race([
    serverHealthCheck(),
    dockerKilled(),
    timeout,
  ]);

  spinner.stop();
  if (!success) {
    throw new Error("Server fails to start");
  }
};

const stopServer = async (checkDir: string) => {
  // Stopping server...
  const dockerDown = new Deno.Command("docker", {
    args: ["compose", "down"],
    cwd: checkDir,
  });
  await dockerDown.output();
};

const check = async (checkDir: string) => {
  console.log(`* Checking ${checkDir}`);

  await startServer(checkDir);
  const response = await checkUrl(localBaseUrl);
  await stopServer(checkDir);

  return response;
};

const checkUrl = async (baseURL: string) => {
  const loginURL = new URL("/login", baseURL);
  const logoURL = new URL("/logo", baseURL);

  // Access logo as logged-in user
  const cookies = (await fetch(loginURL, { method: "post" })).headers
    .getSetCookie();
  if (cookies.length === 0) {
    throw new Error("No cookies found :(");
  }
  const fetchForAdmin = [...Array(5)].map((_) => {
    return fetch(logoURL, { headers: { Cookie: cookies.join(";") } });
  });
  const resForAdmin = await Promise.all(fetchForAdmin);
  const requestIds = resForAdmin.map((r) => r.headers.get("x-request-id"));
  const cachedCookiesForAdmin = resForAdmin.map((r) =>
    r.headers.getSetCookie()
  );

  await delay(100);

  // Access logo as non-logged-in user
  const fetchForAnonymous = [...Array(3)].map((_) => {
    return fetch(logoURL);
  });
  const resForAnonymous = await Promise.all(fetchForAnonymous);

  // Check if response is cached
  let isCookieCached = false;
  let isResponseCached = false;
  resForAnonymous.forEach((res) => {
    // Look if the server caches the cookie or not
    const cachedCookies = res.headers.getSetCookie();
    if (cachedCookies.length > 0) {
      const sameCookie = cachedCookiesForAdmin.find((cookies) => {
        return cookies.join(";") === cachedCookies.join(";");
      });
      if (sameCookie !== undefined) {
        console.log("Cookie leaked:", sameCookie.join(";"));
        isCookieCached = true;
      }
    }

    // Look if the server caches the response or not
    // Compare with x-request-id header
    const requestId = res.headers.get("x-request-id");
    if (requestId && requestIds.includes(requestId)) {
      isResponseCached = true;
    }
  });

  return { isCookieCached, isResponseCached };
};

const checkDefaultDirs = async () => {
  const targets: { dir: string }[] = [
    { dir: "nginx" },
    { dir: "apache" },
    { dir: "haproxy" },
    { dir: "passenger" },
  ];

  for (const target of targets) {
    const result = await check(target.dir);
    console.log(result);
  }
};

const main = async () => {
  const url = Deno.args[0];
  if (url) {
    const result = await checkUrl(url);
    console.log(result);
  } else {
    await checkDefaultDirs();
  }
  Deno.exit();
};
main();