Public release release-5792a1a4e1cb
Source commit: 5792a1a4e1cb24ff71b1535d4b582ef980880752 Public tree identity: sha256:eea1f740446827ef10e4892923c13f13077c9e03438f2bf53d7f90536fb4cf95
This commit is contained in:
Clusterflux release
commit
a6b866e279
210 changed files with 78563 additions and 0 deletions
479
scripts/windows-runner-smoke.js
Executable file
479
scripts/windows-runner-smoke.js
Executable file
|
|
@ -0,0 +1,479 @@
|
|||
#!/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);
|
||||
});
|
||||
Loading…
Add table
Add a link
Reference in a new issue