0cf66aaa65
Source commit: e570b80c3a0f4b152a9aa0e7bb8635b3eebcec27 Public tree identity: sha256:cff3388143eb2e9476804cfa1c1246e3a46d485d8aef90f2cdd4df45f2b69abf
479 lines
14 KiB
JavaScript
Executable file
479 lines
14 KiB
JavaScript
Executable file
#!/usr/bin/env node
|
|
|
|
const assert = require("assert");
|
|
const cp = require("child_process");
|
|
const crypto = require("crypto");
|
|
const fs = require("fs");
|
|
const net = require("net");
|
|
const path = require("path");
|
|
const { coordinatorWireRequest } = require("./coordinator-wire");
|
|
const { nodeIdentity, signedNodeRequest } = require("./node-signing");
|
|
|
|
const repo = path.resolve(__dirname, "..");
|
|
const forgejoWindowsNode = "forgejo-windows-node";
|
|
const forgejoWindowsIdentity = nodeIdentity("windows-runner-smoke", forgejoWindowsNode);
|
|
const windowsEnvironmentDigest = `sha256:${crypto
|
|
.createHash("sha256")
|
|
.update("clusterflux/windows-command-dev/v1")
|
|
.digest("hex")}`;
|
|
const sourceSnapshot = `sha256:${crypto
|
|
.createHash("sha256")
|
|
.update("clusterflux/windows-runner/source/v1")
|
|
.digest("hex")}`;
|
|
|
|
class DapClient {
|
|
constructor() {
|
|
this.child = cp.spawn(
|
|
"cargo",
|
|
["run", "-q", "-p", "clusterflux-dap", "--bin", "clusterflux-debug-dap"],
|
|
{ cwd: repo }
|
|
);
|
|
this.seq = 1;
|
|
this.buffer = Buffer.alloc(0);
|
|
this.messages = [];
|
|
this.waiters = [];
|
|
this.stderr = "";
|
|
|
|
this.child.stdout.on("data", (chunk) => {
|
|
this.buffer = Buffer.concat([this.buffer, chunk]);
|
|
this.parse();
|
|
});
|
|
this.child.stderr.on("data", (chunk) => {
|
|
this.stderr += chunk.toString();
|
|
});
|
|
this.child.on("exit", () => this.flushWaiters());
|
|
}
|
|
|
|
send(command, args = {}) {
|
|
const seq = this.seq++;
|
|
const message = { seq, type: "request", command, arguments: args };
|
|
const payload = Buffer.from(JSON.stringify(coordinatorWireRequest(message)));
|
|
this.child.stdin.write(`Content-Length: ${payload.length}\r\n\r\n`);
|
|
this.child.stdin.write(payload);
|
|
return seq;
|
|
}
|
|
|
|
async response(seq, command) {
|
|
const message = await this.waitFor(
|
|
(item) =>
|
|
item.type === "response" &&
|
|
item.request_seq === seq &&
|
|
item.command === command
|
|
);
|
|
if (!message.success) {
|
|
throw new Error(`DAP ${command} failed: ${message.message || JSON.stringify(coordinatorWireRequest(message))}`);
|
|
}
|
|
return message;
|
|
}
|
|
|
|
waitFor(predicate, timeoutMs = 120000) {
|
|
const existing = this.messages.find(predicate);
|
|
if (existing) return Promise.resolve(existing);
|
|
|
|
return new Promise((resolve, reject) => {
|
|
const timer = setTimeout(() => {
|
|
this.child.kill("SIGKILL");
|
|
reject(new Error(`timed out waiting for DAP message\n${this.stderr}`));
|
|
}, timeoutMs);
|
|
this.waiters.push({ predicate, resolve, timer });
|
|
});
|
|
}
|
|
|
|
parse() {
|
|
while (true) {
|
|
const headerEnd = this.buffer.indexOf("\r\n\r\n");
|
|
if (headerEnd < 0) return;
|
|
const header = this.buffer.slice(0, headerEnd).toString();
|
|
const match = header.match(/Content-Length: (\d+)/i);
|
|
if (!match) throw new Error(`bad DAP header: ${header}`);
|
|
const length = Number(match[1]);
|
|
const start = headerEnd + 4;
|
|
const end = start + length;
|
|
if (this.buffer.length < end) return;
|
|
const payload = this.buffer.slice(start, end).toString();
|
|
this.buffer = this.buffer.slice(end);
|
|
this.messages.push(JSON.parse(payload));
|
|
this.flushWaiters();
|
|
}
|
|
}
|
|
|
|
flushWaiters() {
|
|
for (const waiter of [...this.waiters]) {
|
|
const message = this.messages.find(waiter.predicate);
|
|
if (!message) continue;
|
|
clearTimeout(waiter.timer);
|
|
this.waiters.splice(this.waiters.indexOf(waiter), 1);
|
|
waiter.resolve(message);
|
|
}
|
|
}
|
|
|
|
async close() {
|
|
if (this.child.exitCode !== null) return;
|
|
const seq = this.send("disconnect");
|
|
await this.response(seq, "disconnect");
|
|
this.child.stdin.end();
|
|
}
|
|
}
|
|
|
|
function waitForJsonLine(child) {
|
|
return new Promise((resolve, reject) => {
|
|
let buffer = "";
|
|
child.stdout.on("data", (chunk) => {
|
|
buffer += chunk.toString();
|
|
const newline = buffer.indexOf("\n");
|
|
if (newline < 0) return;
|
|
try {
|
|
resolve(JSON.parse(buffer.slice(0, newline).trim()));
|
|
} catch (error) {
|
|
reject(error);
|
|
}
|
|
});
|
|
child.once("exit", (code) => {
|
|
reject(new Error(`process exited before JSON line with code ${code}`));
|
|
});
|
|
});
|
|
}
|
|
|
|
function send(addr, message) {
|
|
return new Promise((resolve, reject) => {
|
|
const socket = net.connect(addr.port, addr.host, () => {
|
|
socket.write(`${JSON.stringify(coordinatorWireRequest(message))}\n`);
|
|
});
|
|
let buffer = "";
|
|
socket.on("data", (chunk) => {
|
|
buffer += chunk.toString();
|
|
const newline = buffer.indexOf("\n");
|
|
if (newline < 0) return;
|
|
socket.end();
|
|
try {
|
|
resolve(JSON.parse(buffer.slice(0, newline)));
|
|
} catch (error) {
|
|
reject(error);
|
|
}
|
|
});
|
|
socket.on("error", reject);
|
|
});
|
|
}
|
|
|
|
function runWindowsAttach(addr, grant) {
|
|
return new Promise((resolve, reject) => {
|
|
const child = cp.spawn(
|
|
"cargo",
|
|
[
|
|
"run",
|
|
"-q",
|
|
"-p",
|
|
"clusterflux-cli",
|
|
"--bin",
|
|
"clusterflux",
|
|
"--",
|
|
"node",
|
|
"attach",
|
|
"--coordinator",
|
|
`${addr.host}:${addr.port}`,
|
|
"--tenant",
|
|
"tenant",
|
|
"--project-id",
|
|
"project",
|
|
"--node",
|
|
forgejoWindowsNode,
|
|
"--public-key",
|
|
forgejoWindowsIdentity.publicKey,
|
|
"--enrollment-grant",
|
|
grant,
|
|
"--cap",
|
|
"windows-command-dev",
|
|
"--json"
|
|
],
|
|
{
|
|
cwd: repo,
|
|
env: {
|
|
...process.env,
|
|
CLUSTERFLUX_NODE_PRIVATE_KEY: forgejoWindowsIdentity.privateKey,
|
|
},
|
|
}
|
|
);
|
|
let stdout = "";
|
|
let stderr = "";
|
|
child.stdout.on("data", (chunk) => {
|
|
stdout += chunk.toString();
|
|
});
|
|
child.stderr.on("data", (chunk) => {
|
|
stderr += chunk.toString();
|
|
});
|
|
child.on("exit", (code) => {
|
|
if (code !== 0) {
|
|
reject(new Error(`Windows node attach failed with code ${code}\n${stderr}`));
|
|
return;
|
|
}
|
|
try {
|
|
resolve(JSON.parse(stdout));
|
|
} catch (error) {
|
|
reject(
|
|
new Error(`Windows node attach output was not JSON: ${stdout}\n${error.stack || error.message}`)
|
|
);
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
function runWindowsNode(addr, grant) {
|
|
return new Promise((resolve, reject) => {
|
|
const child = cp.spawn(
|
|
"cargo",
|
|
[
|
|
"run",
|
|
"-q",
|
|
"-p",
|
|
"clusterflux-node",
|
|
"--bin",
|
|
"clusterflux-node",
|
|
"--",
|
|
"--coordinator",
|
|
`${addr.host}:${addr.port}`,
|
|
"--tenant",
|
|
"tenant",
|
|
"--project-id",
|
|
"project",
|
|
"--node",
|
|
forgejoWindowsNode,
|
|
"--public-key",
|
|
forgejoWindowsIdentity.publicKey,
|
|
"--enrollment-grant",
|
|
grant,
|
|
"--process",
|
|
"vp-forgejo-windows",
|
|
"--task",
|
|
"windows-command-dev",
|
|
"--command",
|
|
"cmd",
|
|
"--arg",
|
|
"/C",
|
|
"--arg",
|
|
"echo clusterflux-windows-runner",
|
|
"--artifact",
|
|
"/vfs/artifacts/windows-runner-output.txt"
|
|
],
|
|
{
|
|
cwd: repo,
|
|
env: {
|
|
...process.env,
|
|
CLUSTERFLUX_NODE_PRIVATE_KEY: forgejoWindowsIdentity.privateKey,
|
|
},
|
|
}
|
|
);
|
|
let stdout = "";
|
|
let stderr = "";
|
|
child.stdout.on("data", (chunk) => {
|
|
stdout += chunk.toString();
|
|
});
|
|
child.stderr.on("data", (chunk) => {
|
|
stderr += chunk.toString();
|
|
});
|
|
child.on("exit", (code) => {
|
|
if (code !== 0) {
|
|
reject(new Error(`Windows node smoke failed with code ${code}\n${stderr}`));
|
|
return;
|
|
}
|
|
try {
|
|
resolve(JSON.parse(stdout.trim().split(/\r?\n/).at(-1)));
|
|
} catch (error) {
|
|
reject(new Error(`node output was not JSON: ${stdout}\n${error.stack || error.message}`));
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
async function assertDebuggerShowsWindowsThread() {
|
|
const client = new DapClient();
|
|
try {
|
|
const initialize = client.send("initialize", {
|
|
adapterID: "clusterflux",
|
|
linesStartAt1: true,
|
|
columnsStartAt1: true
|
|
});
|
|
await client.response(initialize, "initialize");
|
|
|
|
const launch = client.send("launch", {
|
|
entry: "build",
|
|
project: path.join(repo, "examples/launch-build-demo"),
|
|
runtimeBackend: "simulated"
|
|
});
|
|
await client.response(launch, "launch");
|
|
await client.waitFor(
|
|
(message) => message.type === "event" && message.event === "initialized"
|
|
);
|
|
|
|
const configurationDone = client.send("configurationDone");
|
|
await client.response(configurationDone, "configurationDone");
|
|
|
|
const threadsRequest = client.send("threads");
|
|
const threads = (await client.response(threadsRequest, "threads")).body.threads;
|
|
assert(
|
|
threads.some((thread) => thread.name.includes("compile windows")),
|
|
"debugger must represent the Windows task as a virtual thread"
|
|
);
|
|
|
|
await client.close();
|
|
} catch (error) {
|
|
client.child.kill("SIGKILL");
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
(async () => {
|
|
if (process.platform !== "win32") {
|
|
throw new Error(
|
|
`Windows runner validation requires win32; current platform is ${process.platform}`
|
|
);
|
|
}
|
|
|
|
const coordinator = cp.spawn(
|
|
"cargo",
|
|
[
|
|
"run",
|
|
"-q",
|
|
"-p",
|
|
"clusterflux-coordinator",
|
|
"--bin",
|
|
"clusterflux-coordinator",
|
|
"--",
|
|
"--listen",
|
|
"127.0.0.1:0",
|
|
"--allow-local-trusted-loopback"
|
|
],
|
|
{ cwd: repo }
|
|
);
|
|
let coordinatorStderr = "";
|
|
coordinator.stderr.on("data", (chunk) => {
|
|
coordinatorStderr += chunk.toString();
|
|
});
|
|
|
|
try {
|
|
const ready = await waitForJsonLine(coordinator);
|
|
const [host, portText] = ready.listen.split(":");
|
|
const addr = { host, port: Number(portText) };
|
|
assert.strictEqual((await send(addr, { type: "ping" })).type, "pong");
|
|
|
|
const attachGrant = await send(addr, {
|
|
type: "create_node_enrollment_grant",
|
|
tenant: "tenant",
|
|
project: "project",
|
|
actor_user: "operator",
|
|
ttl_seconds: 900
|
|
});
|
|
assert.strictEqual(attachGrant.type, "node_enrollment_grant_created");
|
|
assert.strictEqual(attachGrant.scope, "node:attach");
|
|
|
|
const attach = await runWindowsAttach(addr, attachGrant.grant);
|
|
assert.strictEqual(attach.plan.node, forgejoWindowsNode);
|
|
assert.strictEqual(attach.boundary.cli_contacted_coordinator, true);
|
|
assert.strictEqual(attach.boundary.used_enrollment_exchange, true);
|
|
assert.strictEqual(attach.coordinator_response.type, "node_enrollment_exchanged");
|
|
assert.strictEqual(attach.coordinator_response.credential.scope, "node:attach");
|
|
assert(attach.plan.capabilities.capabilities.includes("WindowsCommandDev"));
|
|
|
|
const runtimeGrant = await send(addr, {
|
|
type: "create_node_enrollment_grant",
|
|
tenant: "tenant",
|
|
project: "project",
|
|
actor_user: "operator",
|
|
ttl_seconds: 900
|
|
});
|
|
assert.strictEqual(runtimeGrant.type, "node_enrollment_grant_created");
|
|
|
|
const report = await runWindowsNode(addr, runtimeGrant.grant);
|
|
assert.strictEqual(report.node_status, "completed");
|
|
assert.strictEqual(report.virtual_thread, "windows-command-dev");
|
|
assert.strictEqual(report.status_code, 0);
|
|
assert.strictEqual(report.large_bytes_uploaded, false);
|
|
assert.strictEqual(
|
|
report.staged_artifact.path,
|
|
"/vfs/artifacts/windows-runner-output.txt"
|
|
);
|
|
assert.strictEqual(report.registration_response.type, "node_enrollment_exchanged");
|
|
assert.strictEqual(report.registration_response.credential.scope, "node:attach");
|
|
assert.strictEqual(report.coordinator_response.type, "task_recorded");
|
|
|
|
const recorded = await send(addr, signedNodeRequest(forgejoWindowsNode, forgejoWindowsIdentity, "report_node_capabilities", {
|
|
type: "report_node_capabilities",
|
|
tenant: "tenant",
|
|
project: "project",
|
|
node: forgejoWindowsNode,
|
|
capabilities: {
|
|
os: "Windows",
|
|
arch: "x86_64",
|
|
capabilities: ["Command", "WindowsCommandDev", "VfsArtifacts"],
|
|
environment_backends: ["WindowsCommandDev"],
|
|
source_providers: ["filesystem"]
|
|
},
|
|
cached_environment_digests: [windowsEnvironmentDigest],
|
|
source_snapshots: [sourceSnapshot],
|
|
artifact_locations: ["windows-runner-output.txt"],
|
|
direct_connectivity: true,
|
|
online: true
|
|
}));
|
|
assert.strictEqual(recorded.type, "node_capabilities_recorded");
|
|
|
|
const placement = await send(addr, {
|
|
type: "schedule_task",
|
|
tenant: "tenant",
|
|
project: "project",
|
|
environment: {
|
|
os: "Windows",
|
|
arch: null,
|
|
capabilities: ["WindowsCommandDev"]
|
|
},
|
|
environment_digest: windowsEnvironmentDigest,
|
|
required_capabilities: ["Command"],
|
|
source_snapshot: sourceSnapshot,
|
|
required_artifacts: ["windows-runner-output.txt"],
|
|
prefer_node: null
|
|
});
|
|
assert.strictEqual(placement.type, "task_placement");
|
|
assert.strictEqual(placement.placement.node, "forgejo-windows-node");
|
|
|
|
const link = await send(addr, {
|
|
type: "create_artifact_download_link",
|
|
tenant: "tenant",
|
|
project: "project",
|
|
actor_user: "user",
|
|
artifact: "windows-runner-output.txt",
|
|
max_bytes: 1024
|
|
});
|
|
assert.strictEqual(link.type, "artifact_download_link");
|
|
assert.deepStrictEqual(link.link.source, {
|
|
RetainedNode: "forgejo-windows-node"
|
|
});
|
|
} catch (error) {
|
|
if (coordinatorStderr) {
|
|
error.message = `${error.message}\ncoordinator stderr:\n${coordinatorStderr}`;
|
|
}
|
|
throw error;
|
|
} finally {
|
|
coordinator.kill("SIGTERM");
|
|
}
|
|
|
|
await assertDebuggerShowsWindowsThread();
|
|
|
|
const outDir = path.join(repo, "target", "acceptance");
|
|
fs.mkdirSync(outDir, { recursive: true });
|
|
fs.writeFileSync(
|
|
path.join(outDir, "windows-runner.json"),
|
|
`${JSON.stringify(
|
|
{
|
|
kind: "clusterflux_windows_runner_validation",
|
|
platform: process.platform,
|
|
runner: process.env.FORGEJO_RUNNER_NAME || process.env.RUNNER_NAME || null,
|
|
validated: true
|
|
},
|
|
null,
|
|
2
|
|
)}\n`
|
|
);
|
|
|
|
console.log("Windows runner smoke passed");
|
|
})().catch((error) => {
|
|
console.error(error.stack || error.message);
|
|
process.exit(1);
|
|
});
|