feat(lanes): per-lane database, Redis, and .env isolation (A1+A2)
Gives each lane its own slot-derived runtime (ports, detached process lifecycle, profile-driven hooks) and its own database/Redis logical index/.env file, so two lanes running the same repo's stack at once no longer share state. Machine-level DB/Redis credentials live at ~/.ccam/secrets.env (mode 0600, never returned by any route); a hook's output is redacted of that password (raw and URL-encoded forms) before it reaches a log file or the lane_hook_output websocket broadcast. Wired into provision/up/reset/remove; reset accepts --keep-db to skip the drop/recreate/migrate/reseed block entirely.
This commit is contained in:
@@ -0,0 +1,369 @@
|
||||
/**
|
||||
* @file Tests for lane runtime isolation: slot and port allocation, profile
|
||||
* parsing and hook execution, and the boot/down lifecycle.
|
||||
*
|
||||
* The lifecycle tests run a REAL profile whose boot hook starts a REAL server and
|
||||
* whose health hook polls it, because the properties worth proving are exactly
|
||||
* the ones a mock cannot show: that a service detached by `harness_spawn` keeps
|
||||
* listening after the hook exits, that runtime facts recomputed from scratch still
|
||||
* find it (the "survives a dashboard restart" claim), and that `downLane` reaches
|
||||
* a process it never spawned directly.
|
||||
* @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
|
||||
*/
|
||||
|
||||
const os = require("node:os");
|
||||
const pathMod = require("node:path");
|
||||
const fsMod = require("node:fs");
|
||||
|
||||
const SUITE_ROOT = fsMod.mkdtempSync(pathMod.join(os.tmpdir(), "ccam-runtime-"));
|
||||
process.env.DASHBOARD_DB_PATH = pathMod.join(SUITE_ROOT, "dashboard.db");
|
||||
process.env.LANES_ROOT = pathMod.join(SUITE_ROOT, "lanes");
|
||||
|
||||
const { describe, it, after } = require("node:test");
|
||||
const assert = require("node:assert/strict");
|
||||
const net = require("node:net");
|
||||
|
||||
const lanesLib = require("../lib/lanes");
|
||||
const slots = require("../lib/lane-slots");
|
||||
const profileLib = require("../lib/lane-profile");
|
||||
const runtime = require("../lib/lane-runtime");
|
||||
const { isListening } = require("../lib/ports");
|
||||
|
||||
after(() => fsMod.rmSync(SUITE_ROOT, { recursive: true, force: true }));
|
||||
|
||||
let laneSeq = 0;
|
||||
/** A lane row backed by a real directory, so profile lookup and mkdir work. */
|
||||
function makeLane(over = {}) {
|
||||
laneSeq += 1;
|
||||
const cwd = pathMod.join(SUITE_ROOT, `lane-cwd-${laneSeq}`);
|
||||
fsMod.mkdirSync(cwd, { recursive: true });
|
||||
return lanesLib.createLane({ title: `lane ${laneSeq}`, cwd, kind: "managed", ...over });
|
||||
}
|
||||
|
||||
/** Write a profile into a repo directory. `hooks` maps name -> script body. */
|
||||
function writeProfile(root, envText, hooks = {}) {
|
||||
const dir = pathMod.join(root, ".ccam", "profile");
|
||||
fsMod.mkdirSync(pathMod.join(dir, "hooks"), { recursive: true });
|
||||
fsMod.writeFileSync(pathMod.join(dir, "profile.env"), envText);
|
||||
for (const [name, body] of Object.entries(hooks)) {
|
||||
const file = pathMod.join(dir, "hooks", `${name}.sh`);
|
||||
fsMod.writeFileSync(file, body);
|
||||
fsMod.chmodSync(file, 0o755);
|
||||
}
|
||||
return dir;
|
||||
}
|
||||
|
||||
/** Hold a port open so the allocator has to step aside. */
|
||||
function occupy(port) {
|
||||
const server = net.createServer(() => {});
|
||||
return new Promise((resolve, reject) => {
|
||||
server.once("error", reject);
|
||||
server.listen(port, "127.0.0.1", () => resolve(server));
|
||||
});
|
||||
}
|
||||
|
||||
describe("profile parsing", () => {
|
||||
it("keeps command substitution literal instead of executing it", () => {
|
||||
const parsed = profileLib.parseEnvFile(
|
||||
['PORTS="api fe"', "export EVIL=$(id)", "TICK=`whoami`", "# comment", "", "BARE=plain"].join(
|
||||
"\n"
|
||||
)
|
||||
);
|
||||
assert.equal(parsed.PORTS, "api fe");
|
||||
assert.equal(parsed.EVIL, "$(id)");
|
||||
assert.equal(parsed.TICK, "`whoami`");
|
||||
assert.equal(parsed.BARE, "plain");
|
||||
assert.equal(parsed["# comment"], undefined);
|
||||
});
|
||||
|
||||
it("fills defaults for omitted declarations", () => {
|
||||
const lane = makeLane();
|
||||
writeProfile(lane.cwd, "PORTS=web\n");
|
||||
const profile = profileLib.resolveProfile(lane);
|
||||
assert.deepEqual(profile.ports, ["web"]);
|
||||
assert.equal(profile.env.PORT_BASE_fe, "3000");
|
||||
assert.equal(profile.env.BACKEND_DIR, "backend");
|
||||
});
|
||||
|
||||
it("returns null when no profile exists, without throwing", () => {
|
||||
const lane = makeLane();
|
||||
assert.equal(profileLib.resolveProfile(lane), null);
|
||||
});
|
||||
|
||||
it("prefers the lane's own working copy over the source repo", () => {
|
||||
const source = pathMod.join(SUITE_ROOT, "source-repo");
|
||||
fsMod.mkdirSync(source, { recursive: true });
|
||||
writeProfile(source, "PORTS=fromsource\n");
|
||||
const lane = makeLane({ source_repo: source });
|
||||
writeProfile(lane.cwd, "PORTS=fromlane\n");
|
||||
assert.deepEqual(profileLib.resolveProfile(lane).ports, ["fromlane"]);
|
||||
});
|
||||
|
||||
it("falls back to the source repo when the worktree has none", () => {
|
||||
const source = pathMod.join(SUITE_ROOT, "source-repo-2");
|
||||
fsMod.mkdirSync(source, { recursive: true });
|
||||
writeProfile(source, "PORTS=fromsource\n");
|
||||
const lane = makeLane({ source_repo: source });
|
||||
assert.deepEqual(profileLib.resolveProfile(lane).ports, ["fromsource"]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("slot allocation", () => {
|
||||
it("hands out the lowest free slot and reuses a released one", () => {
|
||||
const made = [];
|
||||
for (let i = 0; i < 4; i += 1) {
|
||||
const lane = makeLane();
|
||||
slots.allocateSlot(lane.id);
|
||||
made.push(lanesLib.getLane(lane.id));
|
||||
}
|
||||
assert.deepEqual(
|
||||
made.map((lane) => lane.slot),
|
||||
[1, 2, 3, 4]
|
||||
);
|
||||
|
||||
slots.releaseSlot(made[1].id);
|
||||
assert.equal(lanesLib.getLane(made[1].id).slot, null);
|
||||
|
||||
const next = makeLane();
|
||||
assert.equal(slots.allocateSlot(next.id), 2);
|
||||
|
||||
for (const lane of [...made, next]) slots.releaseSlot(lane.id);
|
||||
});
|
||||
|
||||
it("refuses to allocate past the configured ceiling", () => {
|
||||
const previous = process.env.LANE_MAX_SLOTS;
|
||||
process.env.LANE_MAX_SLOTS = "2";
|
||||
const made = [makeLane(), makeLane(), makeLane()];
|
||||
slots.allocateSlot(made[0].id);
|
||||
slots.allocateSlot(made[1].id);
|
||||
assert.throws(
|
||||
() => slots.allocateSlot(made[2].id),
|
||||
(err) => err.code === "ESLOTS"
|
||||
);
|
||||
for (const lane of made) slots.releaseSlot(lane.id);
|
||||
if (previous === undefined) delete process.env.LANE_MAX_SLOTS;
|
||||
else process.env.LANE_MAX_SLOTS = previous;
|
||||
});
|
||||
});
|
||||
|
||||
describe("port allocation", () => {
|
||||
it("derives base + slot when the port is free", async () => {
|
||||
const lane = makeLane();
|
||||
writeProfile(lane.cwd, "PORTS=api\nPORT_BASE_api=18500\n");
|
||||
slots.allocateSlot(lane.id);
|
||||
const current = lanesLib.getLane(lane.id);
|
||||
const ports = await slots.resolvePorts(current, profileLib.resolveProfile(current));
|
||||
assert.equal(ports.api, 18500 + current.slot);
|
||||
slots.releaseSlot(lane.id);
|
||||
});
|
||||
|
||||
it("steps aside by 100 when the preferred port is taken, keeping the slot digit", async () => {
|
||||
const lane = makeLane();
|
||||
writeProfile(lane.cwd, "PORTS=api\nPORT_BASE_api=18600\n");
|
||||
slots.allocateSlot(lane.id);
|
||||
const current = lanesLib.getLane(lane.id);
|
||||
const held = await occupy(18600 + current.slot);
|
||||
try {
|
||||
const ports = await slots.resolvePorts(current, profileLib.resolveProfile(current));
|
||||
assert.equal(ports.api, 18700 + current.slot);
|
||||
assert.equal(ports.api % 10, current.slot % 10);
|
||||
} finally {
|
||||
held.close();
|
||||
slots.releaseSlot(lane.id);
|
||||
}
|
||||
});
|
||||
|
||||
it("never reuses a port another lane has recorded, even while that lane is down", async () => {
|
||||
const a = makeLane();
|
||||
const b = makeLane();
|
||||
writeProfile(a.cwd, "PORTS=api\nPORT_BASE_api=18800\n");
|
||||
// b's base is offset so its preferred number collides with a's recorded one.
|
||||
slots.allocateSlot(a.id);
|
||||
const laneA = lanesLib.getLane(a.id);
|
||||
lanesLib.setProvisioningFacts(laneA.id, { ports: { api: 18800 + laneA.slot } });
|
||||
|
||||
slots.allocateSlot(b.id);
|
||||
const laneB = lanesLib.getLane(b.id);
|
||||
writeProfile(b.cwd, `PORTS=api\nPORT_BASE_api=${18800 + laneA.slot - laneB.slot}\n`);
|
||||
const ports = await slots.resolvePorts(laneB, profileLib.resolveProfile(laneB));
|
||||
assert.notEqual(ports.api, 18800 + laneA.slot);
|
||||
|
||||
slots.releaseSlot(a.id);
|
||||
slots.releaseSlot(b.id);
|
||||
});
|
||||
});
|
||||
|
||||
describe("hook execution", () => {
|
||||
it("exports the lane contract and scrubs inherited git variables", async () => {
|
||||
const lane = makeLane();
|
||||
writeProfile(lane.cwd, "PORTS=api\nPORT_BASE_api=18900\nCUSTOM=from-profile\n", {
|
||||
boot: '#!/usr/bin/env bash\necho "LANE=$LANE API_PORT=$API_PORT CUSTOM=$CUSTOM GITDIR=[${GIT_DIR:-unset}] ARG=$1"\n',
|
||||
});
|
||||
slots.allocateSlot(lane.id);
|
||||
lanesLib.setProvisioningFacts(lane.id, { ports: { api: 18999 } });
|
||||
const current = lanesLib.getLane(lane.id);
|
||||
|
||||
process.env.GIT_DIR = "/somewhere/else/.git";
|
||||
try {
|
||||
const result = await profileLib.runHook(current, profileLib.resolveProfile(current), "boot", [
|
||||
"--no-build",
|
||||
]);
|
||||
assert.equal(result.code, 0);
|
||||
assert.match(result.output, new RegExp(`LANE=${current.slot}\\b`));
|
||||
assert.match(result.output, /API_PORT=18999/);
|
||||
assert.match(result.output, /CUSTOM=from-profile/);
|
||||
assert.match(result.output, /GITDIR=\[unset\]/);
|
||||
assert.match(result.output, /ARG=--no-build/);
|
||||
} finally {
|
||||
delete process.env.GIT_DIR;
|
||||
slots.releaseSlot(lane.id);
|
||||
}
|
||||
});
|
||||
|
||||
it("rejects a hook name outside the allowlist without spawning anything", async () => {
|
||||
const lane = makeLane();
|
||||
writeProfile(lane.cwd, "PORTS=api\n", { boot: "#!/usr/bin/env bash\ntrue\n" });
|
||||
slots.allocateSlot(lane.id);
|
||||
const current = lanesLib.getLane(lane.id);
|
||||
await assert.rejects(
|
||||
() => profileLib.runHook(current, profileLib.resolveProfile(current), "../../etc/passwd"),
|
||||
(err) => err.code === "ENOHOOK"
|
||||
);
|
||||
slots.releaseSlot(lane.id);
|
||||
});
|
||||
|
||||
it("resolves with the exit code rather than throwing when a hook fails", async () => {
|
||||
const lane = makeLane();
|
||||
writeProfile(lane.cwd, "PORTS=api\n", {
|
||||
boot: '#!/usr/bin/env bash\necho "nope" >&2\nexit 3\n',
|
||||
});
|
||||
slots.allocateSlot(lane.id);
|
||||
const current = lanesLib.getLane(lane.id);
|
||||
const result = await profileLib.runHook(current, profileLib.resolveProfile(current), "boot");
|
||||
assert.equal(result.code, 3);
|
||||
assert.match(result.output, /nope/);
|
||||
assert.ok(fsMod.existsSync(result.logPath));
|
||||
slots.releaseSlot(lane.id);
|
||||
});
|
||||
});
|
||||
|
||||
describe("lifecycle", () => {
|
||||
/** A profile whose boot hook starts a real HTTP listener and detaches it. */
|
||||
function serverProfile(lane, base) {
|
||||
writeProfile(lane.cwd, `PORTS=web\nPORT_BASE_web=${base}\nLANE_DIRS="uploads .cache"\n`, {
|
||||
boot: [
|
||||
"#!/usr/bin/env bash",
|
||||
"set -euo pipefail",
|
||||
'harness_spawn web "$LANE_DIR" python3 -m http.server "$WEB_PORT" --bind 127.0.0.1',
|
||||
"",
|
||||
].join("\n"),
|
||||
health: [
|
||||
"#!/usr/bin/env bash",
|
||||
"set -euo pipefail",
|
||||
"for _ in $(seq 1 50); do",
|
||||
' if curl -sf "http://127.0.0.1:$WEB_PORT/" >/dev/null; then exit 0; fi',
|
||||
" sleep 0.2",
|
||||
"done",
|
||||
"exit 1",
|
||||
"",
|
||||
].join("\n"),
|
||||
});
|
||||
}
|
||||
|
||||
it("boots a detached stack, still sees it after a cold recompute, then stops it", async () => {
|
||||
const lane = makeLane();
|
||||
serverProfile(lane, 19100);
|
||||
|
||||
const facts = await runtime.upLane(lanesLib.getLane(lane.id));
|
||||
assert.equal(facts.available, true);
|
||||
assert.equal(facts.up, true);
|
||||
assert.equal(facts.healthy, true);
|
||||
|
||||
const booted = lanesLib.getLane(lane.id);
|
||||
const port = booted.ports.web;
|
||||
assert.ok(port, "a port was recorded");
|
||||
assert.equal(await isListening(port), true);
|
||||
|
||||
// The declared per-lane directories exist inside the working copy.
|
||||
assert.ok(fsMod.existsSync(pathMod.join(booted.cwd, "uploads")));
|
||||
assert.ok(fsMod.existsSync(pathMod.join(booted.cwd, ".cache")));
|
||||
|
||||
// "Survives a dashboard restart": nothing in memory is consulted — the facts
|
||||
// are rebuilt from the pid file on disk and a fresh port probe.
|
||||
const recomputed = await runtime.runtimeFacts(lanesLib.getLane(lane.id));
|
||||
assert.equal(recomputed.up, true);
|
||||
assert.equal(recomputed.healthy, true);
|
||||
assert.equal(recomputed.services.find((s) => s.name === "web").alive, true);
|
||||
|
||||
await runtime.downLane(lanesLib.getLane(lane.id));
|
||||
assert.equal(await isListening(port), false);
|
||||
const afterDown = await runtime.runtimeFacts(lanesLib.getLane(lane.id));
|
||||
assert.equal(afterDown.up, false);
|
||||
assert.deepEqual(afterDown.services, []);
|
||||
|
||||
slots.releaseSlot(lane.id);
|
||||
});
|
||||
|
||||
it("records a failed health check without touching the lane's agent fields", async () => {
|
||||
const lane = makeLane();
|
||||
writeProfile(lane.cwd, "PORTS=web\nPORT_BASE_web=19200\n", {
|
||||
boot: "#!/usr/bin/env bash\ntrue\n",
|
||||
health: "#!/usr/bin/env bash\nexit 1\n",
|
||||
});
|
||||
|
||||
await assert.rejects(
|
||||
() => runtime.upLane(lanesLib.getLane(lane.id)),
|
||||
(err) => err.code === "EUNHEALTHY"
|
||||
);
|
||||
|
||||
const after = lanesLib.getLane(lane.id);
|
||||
assert.equal(after.stage, "idle", "runtime must not write stage");
|
||||
assert.equal(after.status, "idle", "runtime must not write status");
|
||||
assert.equal(after.notes, null, "runtime must not write notes");
|
||||
|
||||
const facts = await runtime.runtimeFacts(after);
|
||||
assert.equal(facts.lastError.code, "EUNHEALTHY");
|
||||
|
||||
slots.releaseSlot(lane.id);
|
||||
});
|
||||
|
||||
it("reports available:false for a lane with no profile", async () => {
|
||||
const lane = makeLane();
|
||||
const facts = await runtime.runtimeFacts(lane);
|
||||
assert.equal(facts.available, false);
|
||||
assert.ok(facts.searched.length > 0);
|
||||
await assert.rejects(
|
||||
() => runtime.upLane(lane),
|
||||
(err) => err.code === "ENOPROFILE"
|
||||
);
|
||||
});
|
||||
|
||||
it("is a no-op when taking down a lane that was never up", async () => {
|
||||
const lane = makeLane();
|
||||
writeProfile(lane.cwd, "PORTS=web\n", { boot: "#!/usr/bin/env bash\ntrue\n" });
|
||||
assert.deepEqual(await runtime.downLane(lane), { killed: [] });
|
||||
});
|
||||
|
||||
it("refuses a LANE_DIRS entry that escapes the working copy", () => {
|
||||
const lane = makeLane();
|
||||
writeProfile(lane.cwd, 'PORTS=web\nLANE_DIRS="../escaped"\n');
|
||||
assert.throws(
|
||||
() => runtime.makeLaneDirs(lane, profileLib.resolveProfile(lane)),
|
||||
(err) => err.code === "EBADLANEDIR"
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe("allocation is not client-patchable", () => {
|
||||
it("ignores slot and ports coming through updateLane", () => {
|
||||
const lane = makeLane();
|
||||
slots.allocateSlot(lane.id);
|
||||
const before = lanesLib.getLane(lane.id);
|
||||
lanesLib.updateLane(lane.id, { slot: 99, ports: { api: 1 }, title: "renamed" });
|
||||
const after = lanesLib.getLane(lane.id);
|
||||
assert.equal(after.slot, before.slot);
|
||||
assert.deepEqual(after.ports, before.ports);
|
||||
assert.equal(after.title, "renamed", "patchable fields still apply");
|
||||
slots.releaseSlot(lane.id);
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user