c1769967c1
Source commit: 01875e88a3e25379c309489f9f057dd97c0d37de Public tree identity: sha256:8f37a1aa0cc8f408975daf9cabbe193f8f4c169c6d25e8795e67a3ed5083c76b
299 lines
10 KiB
JavaScript
Executable file
299 lines
10 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 digest = (value) =>
|
|
`sha256:${crypto.createHash("sha256").update(value).digest("hex")}`;
|
|
const environmentDigest = digest("windows-command-dev-environment");
|
|
const sourceDigest = digest("windows-best-effort-source");
|
|
const windowsArtifactBytes = Buffer.from("windows-output-data");
|
|
const windowsArtifactDigest = digest(windowsArtifactBytes);
|
|
const emptyWasm = Buffer.from([0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00]);
|
|
const emptyWasmDigest = digest(emptyWasm);
|
|
const nodeDaemon = fs.readFileSync(path.join(repo, "crates/clusterflux-node/src/daemon.rs"), "utf8");
|
|
const taskReports = fs.readFileSync(
|
|
path.join(repo, "crates/clusterflux-node/src/task_reports.rs"),
|
|
"utf8"
|
|
);
|
|
const nodeLib = fs.readFileSync(path.join(repo, "crates/clusterflux-node/src/lib.rs"), "utf8");
|
|
const windowsDev = fs.readFileSync(
|
|
path.join(repo, "crates/clusterflux-node/src/windows_dev.rs"),
|
|
"utf8"
|
|
);
|
|
const executionCore = fs.readFileSync(
|
|
path.join(repo, "crates/clusterflux-core/src/execution.rs"),
|
|
"utf8"
|
|
);
|
|
const dapSource = [
|
|
fs.readFileSync(path.join(repo, "crates/clusterflux-dap/src/demo_backend.rs"), "utf8"),
|
|
fs.readFileSync(path.join(repo, "crates/clusterflux-dap/src/tests.rs"), "utf8"),
|
|
].join("\n");
|
|
const windowsNode = "windows-node";
|
|
const windowsIdentity = nodeIdentity("windows-best-effort-smoke", windowsNode);
|
|
|
|
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 windowsCapabilities() {
|
|
return {
|
|
os: "Windows",
|
|
arch: "x86_64",
|
|
capabilities: ["Command", "VfsArtifacts", "WindowsCommandDev"],
|
|
environment_backends: ["WindowsCommandDev"],
|
|
source_providers: ["filesystem"]
|
|
};
|
|
}
|
|
|
|
function assertWindowsBackendBoundary() {
|
|
assert.match(nodeDaemon, /CoordinatorSession::connect\(&args\.coordinator\)/);
|
|
assert.match(nodeDaemon, /record_completed_task\(/);
|
|
assert.match(taskReports, /"type": "task_completed"/);
|
|
assert.doesNotMatch(nodeDaemon, /WindowsCommandDev|windows-command-dev|cfg\(windows\)/);
|
|
|
|
assert.match(nodeLib, /impl CommandBackend for LinuxRootlessPodmanBackend/);
|
|
assert.match(nodeLib, /mod windows_dev/);
|
|
assert.match(nodeLib, /pub use windows_dev::\{WindowsCommandDevBackend, WindowsSandboxStubBackend\}/);
|
|
assert.match(windowsDev, /impl CommandBackend for WindowsCommandDevBackend/);
|
|
assert.match(windowsDev, /impl CommandBackend for WindowsSandboxStubBackend/);
|
|
assert.doesNotMatch(windowsDev, /LinuxRootlessPodmanBackend/);
|
|
assert.match(executionCore, /\bLinuxRootlessPodman\b/);
|
|
assert.match(executionCore, /\bWindowsCommandDev\b/);
|
|
assert.match(executionCore, /\bStubbedWindowsSandbox\b/);
|
|
|
|
assert.match(dapSource, /thread\(WINDOWS_THREAD, "compile-windows", "compile windows"/);
|
|
assert.match(dapSource, /fn launch_threads_include_windows_task_in_same_virtual_process\(\)/);
|
|
assert.match(dapSource, /fn windows_thread_runtime_variables_share_virtual_process\(\)/);
|
|
}
|
|
|
|
(async () => {
|
|
assertWindowsBackendBoundary();
|
|
|
|
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 attached = await send(addr, {
|
|
type: "attach_node",
|
|
tenant: "tenant",
|
|
project: "project",
|
|
node: windowsNode,
|
|
public_key: windowsIdentity.publicKey
|
|
});
|
|
assert.strictEqual(attached.type, "node_attached");
|
|
assert.strictEqual(attached.node, windowsNode);
|
|
|
|
const recorded = await send(addr, signedNodeRequest(windowsNode, windowsIdentity, "report_node_capabilities", {
|
|
type: "report_node_capabilities",
|
|
tenant: "tenant",
|
|
project: "project",
|
|
node: windowsNode,
|
|
capabilities: windowsCapabilities(),
|
|
cached_environment_digests: [environmentDigest],
|
|
dependency_cache_digests: [],
|
|
source_snapshots: [sourceDigest],
|
|
artifact_locations: [],
|
|
direct_connectivity: true,
|
|
online: true
|
|
}));
|
|
assert.strictEqual(recorded.type, "node_capabilities_recorded");
|
|
assert.strictEqual(recorded.node, windowsNode);
|
|
|
|
const placement = await send(addr, {
|
|
type: "schedule_task",
|
|
tenant: "tenant",
|
|
project: "project",
|
|
environment: {
|
|
os: "Windows",
|
|
arch: null,
|
|
capabilities: ["WindowsCommandDev"]
|
|
},
|
|
environment_digest: environmentDigest,
|
|
required_capabilities: ["Command"],
|
|
dependency_cache: null,
|
|
source_snapshot: sourceDigest,
|
|
required_artifacts: [],
|
|
prefer_node: null
|
|
});
|
|
assert.strictEqual(placement.type, "task_placement");
|
|
assert.strictEqual(placement.placement.node, windowsNode);
|
|
assert.ok(placement.placement.reasons.includes("warm environment cache"));
|
|
assert.ok(placement.placement.reasons.includes("source snapshot already local"));
|
|
|
|
const started = await send(addr, {
|
|
type: "start_process",
|
|
tenant: "tenant",
|
|
project: "project",
|
|
process: "vp-windows"
|
|
});
|
|
assert.strictEqual(started.type, "process_started");
|
|
assert.strictEqual(started.process, "vp-windows");
|
|
|
|
const reconnected = await send(addr, signedNodeRequest(windowsNode, windowsIdentity, "reconnect_node", {
|
|
type: "reconnect_node",
|
|
node: windowsNode,
|
|
process: "vp-windows",
|
|
epoch: started.epoch
|
|
}));
|
|
assert.strictEqual(reconnected.type, "node_reconnected");
|
|
|
|
const launched = await send(addr, {
|
|
type: "launch_task",
|
|
tenant: "tenant",
|
|
project: "project",
|
|
actor_user: "operator",
|
|
task_spec: {
|
|
tenant: "tenant",
|
|
project: "project",
|
|
process: "vp-windows",
|
|
task_definition: "windows-command-dev",
|
|
task_instance: "windows-command-dev",
|
|
dispatch: {
|
|
kind: "coordinator_node_wasm",
|
|
export: "windows_command_dev",
|
|
abi: "task_v1",
|
|
},
|
|
environment_id: "windows",
|
|
environment: {
|
|
os: "Windows",
|
|
arch: null,
|
|
capabilities: ["WindowsCommandDev"],
|
|
},
|
|
environment_digest: environmentDigest,
|
|
required_capabilities: ["Command", "WindowsCommandDev"],
|
|
dependency_cache: null,
|
|
source_snapshot: sourceDigest,
|
|
required_artifacts: [],
|
|
args: [{ SourceSnapshot: sourceDigest }],
|
|
vfs_epoch: started.epoch,
|
|
bundle_digest: emptyWasmDigest,
|
|
},
|
|
wait_for_node: false,
|
|
artifact_path: "/vfs/artifacts/windows-output.txt",
|
|
wasm_module_base64: emptyWasm.toString("base64"),
|
|
});
|
|
assert.strictEqual(launched.type, "error", JSON.stringify(launched));
|
|
assert.match(launched.message, /external callers may launch only EntrypointV1/);
|
|
|
|
const recordedTask = await send(addr, signedNodeRequest(windowsNode, windowsIdentity, "task_completed", {
|
|
type: "task_completed",
|
|
tenant: "tenant",
|
|
project: "project",
|
|
process: "vp-windows",
|
|
node: windowsNode,
|
|
task: "windows-command-dev",
|
|
status_code: 0,
|
|
stdout_bytes: 18,
|
|
stderr_bytes: 0,
|
|
stdout_tail: "",
|
|
stderr_tail: "",
|
|
stdout_truncated: false,
|
|
stderr_truncated: false,
|
|
artifact_path: "/vfs/artifacts/windows-output.txt",
|
|
artifact_digest: windowsArtifactDigest,
|
|
artifact_size_bytes: windowsArtifactBytes.length
|
|
}));
|
|
assert.strictEqual(recordedTask.type, "error");
|
|
assert.match(recordedTask.message, /coordinator-issued task instance|issued active task|active task/);
|
|
|
|
const events = await send(addr, {
|
|
type: "list_task_events",
|
|
tenant: "tenant",
|
|
project: "project",
|
|
actor_user: "user",
|
|
process: "vp-windows"
|
|
});
|
|
assert.strictEqual(events.type, "task_events");
|
|
assert.strictEqual(events.events.length, 0);
|
|
|
|
const link = await send(addr, {
|
|
type: "create_artifact_download_link",
|
|
tenant: "tenant",
|
|
project: "project",
|
|
actor_user: "user",
|
|
artifact: "windows-output.txt",
|
|
max_bytes: 1024
|
|
});
|
|
assert.strictEqual(link.type, "error");
|
|
assert.match(link.message, /does not exist|not found|unavailable/);
|
|
} catch (error) {
|
|
if (coordinatorStderr) {
|
|
error.message = `${error.message}\ncoordinator stderr:\n${coordinatorStderr}`;
|
|
}
|
|
throw error;
|
|
} finally {
|
|
coordinator.kill("SIGTERM");
|
|
}
|
|
|
|
console.log("Windows best-effort smoke passed");
|
|
})().catch((error) => {
|
|
console.error(error.stack || error.message);
|
|
process.exit(1);
|
|
});
|