computer/script/exec-tests at example-javascript · earthlings-dev/computer · GitHub

History

executable file

274 lines (257 loc) · 9.56 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

#!/usr/bin/env bash

# Boot computerd in docker (FUSE-disabled), drive a few exec scenarios

# over the WebSocket from the host, assert outputs, tear down.

# Mirrors `script/shell` for the mount point — the linux computerd

# binary is the only thing bind-mounted into the container. The

# repo isn't mounted: everything else lives in the binary.

# Usage:

# script/exec-tests

# Requires:

# - artifacts/computerd/computerd-linux-x64 (run `npm run build:bin --workspace

# @cloudflare/computerd` first)

# - docker

# - node 22+ on the host

set -euo pipefail

repo_root="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"

binary="${repo_root}/artifacts/computerd/computerd-linux-x64"

port="${PORT:-45678}"

cid_file="$(mktemp -u)"

trap 'cleanup; rm -f "${cid_file}"' EXIT

cleanup() {

if [[ -s "${cid_file}" ]]; then

docker kill "$(cat "${cid_file}")" >/dev/null 2>&1 || true

}

if [[ ! -x "${binary}" ]]; then

echo "missing or non-executable binary: ${binary}" >&2

echo "run \`npm run build:bin --workspace @cloudflare/computerd\` first" >&2

exit 2

echo "==> booting computerd in docker"

docker run --rm -d \

--cidfile "${cid_file}" \

--platform linux/amd64 \

-e PORT="${port}" \

-e FUSE_MOUNT=none \

-e EXEC_LOG_MAX_BYTES=256 \

-p "${port}:${port}" \

-v "${binary}:/usr/local/bin/computerd:ro" \

debian:stable-slim \

/usr/local/bin/computerd >/dev/null

# Wait for /health to come up. computerd binds quickly but pkg-bundled

# binaries do a v8 snapshot warm-up on first launch.

for _ in $(seq 1 30); do

if curl -sf "http://localhost:${port}/health" >/dev/null 2>&1; then

break

sleep 0.5

done

if ! curl -sf "http://localhost:${port}/health" >/dev/null 2>&1; then

echo "computerd did not become healthy on port ${port}" >&2

docker logs "$(cat "${cid_file}")" 2>&1 | tail -20 >&2

exit 1

echo "==> computerd healthy on :${port}"

# Drive the smoke from a node script. Inline so we don't add a

# new file to mount; the script is self-contained.

PORT="${port}" REPO_ROOT="${repo_root}" node --input-type=module -e '

const repoRoot = process.env.REPO_ROOT;

const port = process.env.PORT;

const { createWorkspaceClient } = await import(

`${repoRoot}/node_modules/@cloudflare/computer-rpc/dist/client.js`

);

const assert = (cond, msg) => {

if (!cond) {

console.error("FAIL:", msg);

process.exit(1);

}

};

const client = createWorkspaceClient({ url: `ws://localhost:${port}/ws` });

try {

// 1. echo + exit code.

const h = await client.shell.exec({ command: "echo hello && exit 7" });

const dec = new TextDecoder();

const events = [];

const reader = h.events.getReader();

while (true) {

const { value, done } = await reader.read();

if (done) break;

events.push(value);

}

const stdout = events.filter(e => e.name === "stdout")

.map(e => dec.decode(e.value)).join("");

const exit = events.find(e => e.name === "exit");

assert(stdout === "hello\n", `unexpected stdout: ${JSON.stringify(stdout)}`);

assert(exit && exit.value === 7, `unexpected exit: ${JSON.stringify(exit)}`);

console.log(" PASS exec captures stdout + exit code");

// 1b. EEXEC_BUSY surfaces with the right code over the wire.

// The runner refuses a second exec on a live id; the host

// catches a plain Error with err.code intact (capnweb copies

// own enumerable props on Error subclasses).

const live = await client.shell.exec({ command: "sleep 30", id: "busy" });

let busyErr;

try {

await client.shell.exec({ command: "echo nope", id: "busy" });

} catch (err) {

busyErr = err;

}

assert(busyErr && busyErr.code === "EEXEC_BUSY",

`expected EEXEC_BUSY, got ${busyErr && busyErr.code}`);

await client.shell.killExec({ id: "busy" });

// Drain so the kill resolves cleanly before the next test

// touches the runner.

const liveReader = live.events.getReader();

while (true) {

const { done } = await liveReader.read();

if (done) break;

}

console.log(" PASS EEXEC_BUSY propagates with err.code");

// 2. kill a long-running process.

const long = await client.shell.exec({ command: "sleep 30", id: "killme" });

await client.shell.killExec({ id: "killme", signal: "SIGTERM" });

const longReader = long.events.getReader();

let killExit;

while (true) {

const { value, done } = await longReader.read();

if (done) break;

if (value.name === "exit") killExit = value.value;

}

// SIGTERM → 143 per Runner mapping.

assert(killExit === 143, `kill exit code was ${killExit}`);

console.log(" PASS killExec terminates a running command");

// 3. getExec replays a finished run by seq.

const replay = await client.shell.getExec({ id: "killme", after: 0 });

let count = 0;

const replayReader = replay.events.getReader();

while (true) {

const { value, done } = await replayReader.read();

if (done) break;

count++;

}

assert(count >= 1, `getExec returned no events`);

console.log(" PASS getExec replays finished run");

// 4. disposeExec → subsequent getExec rejects.

await client.shell.disposeExec({ id: "killme" });

let threw = false;

try {

const r = await client.shell.getExec({ id: "killme", after: 0 });

await r.events.getReader().read();

} catch (err) {

threw = true;

}

assert(threw, `getExec after dispose did not throw`);

console.log(" PASS disposeExec evicts the log");

// 5. size-cap eviction → getExec on a fresh exec that

// overflowed the cap raises ELOG_TRUNCATED. EXEC_LOG_MAX_BYTES=256

// on the container makes the cap tiny so even an echo trips it.

const big = await client.shell.exec({

command: "head -c 2048 /dev/urandom | base64",

id: "big",

});

// Drain the live stream first — eviction does not gate live.

const bigReader = big.events.getReader();

while (true) {

const { done } = await bigReader.read();

if (done) break;

}

let truncated = false;

let evictStream;

try {

const r = await client.shell.getExec({ id: "big", after: 0 });

evictStream = r.events;

const reader = r.events.getReader();

try {

while (true) {

const { done } = await reader.read();

if (done) break;

}

} finally {

reader.releaseLock();

}

} catch (err) {

if (err && (err.code === "ELOG_TRUNCATED" || /ELOG_TRUNCATED/.test(err.message))) {

truncated = true;

} else {

throw err;

}

if (evictStream) {

try { await evictStream.cancel(); } catch {}

}

assert(truncated, `expected ELOG_TRUNCATED on evicted log`);

console.log(" PASS ELOG_TRUNCATED surfaces on evicted log");

// 6. backpressure smoke. A chatty command + a slow consumer:

// the runner should pace the child via kernel pipe pressure

// and the consumer should still see every byte. We do not try

// to assert the pause edge directly (no observable signal

// through capnweb); the test is that a 256 KiB stream lands

// intact under a deliberately slow reader.

// 6. backpressure smoke. A chatty command + a slow consumer:

// the runner should pace the child via kernel pipe pressure

// and the consumer should still see every byte. We do not try

// to assert the pause edge directly (no observable signal

// through capnweb); the test is that an 8 KiB stream lands

// intact under a deliberately slow reader. Kept small because

// capnweb 0.8 trips a WritableStream dispose error when the

// flow-control window stalls for long — a real test of pipe

// pause needs a capnweb upgrade or a different observable.

const chatty = await client.shell.exec({

command: "head -c 8192 /dev/urandom | base64",

id: "chatty",

});

let totalBytes = 0;

let sawExit = false;

const cReader = chatty.events.getReader();

while (true) {

const { value, done } = await cReader.read();

if (done) break;

if (value.name === "stdout") totalBytes += value.value.byteLength;

if (value.name === "exit") sawExit = true;

await new Promise((r) => setTimeout(r, 10));

}

assert(sawExit, `chatty stream never saw exit`);

assert(totalBytes > 8000, `expected ~11 KiB of stdout, got ${totalBytes}`);

console.log(` PASS slow reader: ${totalBytes} bytes delivered intact`);

// 7. Workspace.runtime host wrapper (E3). Uses the composite

// client through the high-level facade: encoding utf8 +

// ExecHandle.result() in one call.

// Import the specific files rather than the package barrel.

// The barrel re-exports WorkspaceProxy, which extends

// WorkerEntrypoint from cloudflare:workers — that scheme

// only resolves under workerd, not plain Node.

const { TestBackend } = await import(

`${repoRoot}/packages/computer/dist/backends/test.js`

);

const { Workspace } = await import(

`${repoRoot}/packages/computer/dist/workspace.js`

);

// Workspace needs DurableObjectStorageLike; supply the

// node:sqlite-backed test storage so this runs under plain

// Node. Workerd consumers pass ctx.storage instead.

const { SQLiteTestStorage } = await import(

`${repoRoot}/packages/dofs/dist/testing.js`

);

const ws = new Workspace({

storage: new SQLiteTestStorage(),

backends: [new TestBackend({ url: `http://localhost:${port}` })],

});

try {

await ws.ready();

const handle = await ws.runtime.exec("echo from-workspace && exit 0", {

encoding: "utf8",

});

const { exitCode, stdout } = await handle.result();

assert(stdout === "from-workspace\n", `Workspace.runtime stdout: ${JSON.stringify(stdout)}`);

assert(exitCode === 0, `Workspace.runtime exitCode: ${exitCode}`);

console.log(" PASS Workspace.runtime.exec(...).result() round-trip");

} finally {

await ws.close();

}

} finally {

await client.close();

}

echo "==> all checks passed"

computer/script/exec-tests at example-javascript · earthlings-dev/computer · GitHub

Expand file tree

Breadcrumbs

exec-tests

Latest commit

History

Breadcrumbs

exec-tests

File metadata and controls