@graftland/plugin-remote 0.3.1 → 0.3.2

package/src/internal/runner/Processes.ts

@@ -8,102 +8,99 @@ import {
 	type Termination,
 } from "./model"
 
-const inspect = (pid: number) =>
-	Effect.scoped(
-		Effect.gen(function* () {
-			const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
-			const child = yield* spawner.spawn(
-				ChildProcess.make(
-					"ps",
-					["-p", `${pid}`, "-o", "lstart=", "-o", "stat="],
-					{
-						env: { ...process.env, LC_ALL: "C" },
-						stdin: "ignore",
-					},
-				),
-			)
-			const [code, output, stderr] = yield* Effect.all(
-				[
-					child.exitCode,
-					child.stdout.pipe(Stream.decodeText(), Stream.mkString),
-					child.stderr.pipe(Stream.decodeText(), Stream.mkString),
-				],
-				{ concurrency: "unbounded" },
-			)
-			if (code === 1 && String.trim(output) === "") return Option.none()
-			const [, born, status] =
-				/^(.{24})\s+(\S+)$/m.exec(String.trim(output)) ?? []
-			if (code !== 0 || born === undefined || status === undefined)
-				return yield* ExecutionError.make({
-					detail: "Cannot inspect process identity: " + stderr,
-				})
-			if (String.startsWith("Z")(status)) return Option.none()
-			return Option.some({ born })
-		}),
-	).pipe(
-		Effect.mapError((error) =>
-			error._tag === "ExecutionError"
-				? error
-				: ExecutionError.make({
-						detail: "Inspecting process identity failed",
-						cause: Cause.fail(error),
-					}),
-		),
-	)
-
-export const identity = (pid: number) =>
-	Effect.gen(function* () {
-		const current = yield* inspect(pid)
-		if (Option.isNone(current))
+const inspect = Effect.fnUntraced(
+	function* (pid: number) {
+		const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
+		const child = yield* spawner.spawn(
+			ChildProcess.make(
+				"ps",
+				["-p", `${pid}`, "-o", "lstart=", "-o", "stat="],
+				{
+					env: { LC_ALL: "C" },
+					extendEnv: true,
+					stdin: "ignore",
+				},
+			),
+		)
+		const [code, output, stderr] = yield* Effect.all(
+			[
+				child.exitCode,
+				child.stdout.pipe(Stream.decodeText(), Stream.mkString),
+				child.stderr.pipe(Stream.decodeText(), Stream.mkString),
+			],
+			{ concurrency: "unbounded" },
+		)
+		if (code === 1 && String.trim(output) === "") return Option.none()
+		const [, born, status] =
+			/^(.{24})\s+(\S+)$/m.exec(String.trim(output)) ?? []
+		if (code !== 0 || born === undefined || status === undefined)
 			return yield* ExecutionError.make({
-				detail: "The child exited before its identity could be recorded",
+				detail: "Cannot inspect process identity: " + stderr,
 			})
-		return { pid, start: current.value }
-	})
+		if (String.startsWith("Z")(status)) return Option.none()
+		return Option.some({ born })
+	},
+	Effect.scoped,
+	Effect.mapError((error) =>
+		error._tag === "ExecutionError"
+			? error
+			: ExecutionError.make({
+					detail: "Inspecting process identity failed",
+					cause: Cause.fail(error),
+				}),
+	),
+)
+
+export const identity = Effect.fnUntraced(function* (pid: number) {
+	const current = yield* inspect(pid)
+	if (Option.isNone(current))
+		return yield* ExecutionError.make({
+			detail: "The child exited before its identity could be recorded",
+		})
+	return { pid, start: current.value }
+})
 
 // The OS may discard argv before reporting a zombie; PID and start time remain the identity.
-export const matches = (child: ProcessIdentity) =>
-	Effect.gen(function* () {
-		const current = yield* inspect(child.pid)
-		if (Option.isNone(current) || current.value.born !== child.start.born)
-			return false
-		return true
-	})
+export const matches = Effect.fnUntraced(function* (child: ProcessIdentity) {
+	const current = yield* inspect(child.pid)
+	if (Option.isNone(current) || current.value.born !== child.start.born)
+		return false
+	return true
+})
 
-export const recover = (child: ProcessIdentity) =>
-	Effect.gen(function* () {
-		if (!(yield* matches(child)))
-			return {
-				kind: "Exited",
-				exit: { code: null, signal: null },
-				cause: Cause.empty,
-			} satisfies Termination
-		// The PID can still be reused between this final check and kill; an external supervisor covers descendants.
-		const sent = yield* Effect.exit(
-			Effect.try({
-				try: () => process.kill(child.pid, "SIGKILL"),
-				catch: (cause) =>
-					ExecutionError.make({
-						detail: "Signaling the orphan failed",
-						cause: Cause.die(cause),
-					}),
-			}),
-		)
-		const confirmed = yield* matches(child).pipe(
-			Effect.repeat({
-				schedule: Schedule.spaced("50 millis"),
-				while: (value) => value,
-			}),
-			Effect.timeoutOption("10 seconds"),
-		)
-		if (Option.isNone(confirmed))
-			return yield* TerminationUnconfirmed.make({
-				detail: "The orphan did not exit after recovery",
-				cause: sent._tag === "Failure" ? sent.cause : Cause.empty,
-			})
+export const recover = Effect.fnUntraced(function* (child: ProcessIdentity) {
+	if (!(yield* matches(child)))
 		return {
-			kind: "Killed",
-			exit: { code: null, signal: "SIGKILL" },
-			cause: sent._tag === "Failure" ? sent.cause : Cause.empty,
+			kind: "Exited",
+			exit: { code: null, signal: null },
+			cause: Cause.empty,
 		} satisfies Termination
-	})
+	// The PID can still be reused between this final check and kill; an external supervisor covers descendants.
+	const sent = yield* Effect.exit(
+		Effect.try({
+			try: () => process.kill(child.pid, "SIGKILL"),
+			catch: (cause) =>
+				ExecutionError.make({
+					detail: "Signaling the orphan failed",
+					cause: Cause.die(cause),
+				}),
+		}),
+	)
+	const confirmed = yield* matches(child).pipe(
+		Effect.repeat({
+			schedule: Schedule.spaced("50 millis"),
+			while: (value) => value,
+		}),
+		Effect.timeoutOption("10 seconds"),
+	)
+	if (Option.isNone(confirmed))
+		return yield* TerminationUnconfirmed.make({
+			detail: "The orphan did not exit after recovery",
+			cause: sent._tag === "Failure" ? sent.cause : Cause.empty,
+		})
+	return {
+		kind: "Killed",
+		exit: { code: null, signal: "SIGKILL" },
+		cause: sent._tag === "Failure" ? sent.cause : Cause.empty,
+	} satisfies Termination
+})

package/src/internal/runner/Store.ts

@@ -33,127 +33,123 @@ export const memory = Effect.gen(function* () {
  * Older terminal request ids expire; Open fences their retries with expectedGeneration.
  * Requires exclusive directory ownership; it is not a multi-writer database.
  */
-export const directory = (root: string) =>
-	Effect.gen(function* () {
-		const fs = yield* FileSystem.FileSystem
-		const path = yield* Path.Path
-		const digest = yield* Digest.Digest
-		const json = Schema.fromJsonString(Schema.toCodecJson(SessionRecord))
-		const random = yield* SecureRandom.SecureRandom
-		const storage = <A, R>(
-			effect: Effect.Effect<
-				A,
-				PlatformError.PlatformError | Schema.SchemaError | StateStorageError,
-				R
-			>,
-		) =>
-			effect.pipe(
-				Effect.mapError((error) =>
-					error._tag === "StateStorageError"
-						? error
-						: StateStorageError.make({
-								detail: "Runner state storage failed",
-								cause: Cause.fail(error),
-							}),
+export const directory = Effect.fnUntraced(function* (root: string) {
+	const fs = yield* FileSystem.FileSystem
+	const path = yield* Path.Path
+	const digest = yield* Digest.Digest
+	const json = Schema.fromJsonString(Schema.toCodecJson(SessionRecord))
+	const random = yield* SecureRandom.SecureRandom
+	const storage = <A, R>(
+		effect: Effect.Effect<
+			A,
+			PlatformError.PlatformError | Schema.SchemaError | StateStorageError,
+			R
+		>,
+	) =>
+		effect.pipe(
+			Effect.mapError((error) =>
+				error._tag === "StateStorageError"
+					? error
+					: StateStorageError.make({
+							detail: "Runner state storage failed",
+							cause: Cause.fail(error),
+						}),
+			),
+		)
+	yield* storage(
+		fs.makeDirectory(root, { recursive: true }).pipe(Effect.uninterruptible),
+	)
+	const mutex = yield* Semaphore.make(1)
+	const read = Effect.gen(function* () {
+		const files = yield* fs.readDirectory(root)
+		const rows = yield* Effect.forEach(
+			Array.filter(files, String.endsWith(".json")),
+			(file) =>
+				fs.readFileString(path.join(root, file)).pipe(
+					Effect.flatMap(Schema.decodeEffect(json)),
+					Effect.map((record) => ({ file, record })),
 				),
-			)
-		yield* storage(
-			fs.makeDirectory(root, { recursive: true }).pipe(Effect.uninterruptible),
 		)
-		const mutex = yield* Semaphore.make(1)
-		const read = Effect.gen(function* () {
-			const files = yield* fs.readDirectory(root)
-			const rows = yield* Effect.forEach(
-				Array.filter(files, String.endsWith(".json")),
-				(file) =>
-					fs.readFileString(path.join(root, file)).pipe(
-						Effect.flatMap(Schema.decodeEffect(json)),
-						Effect.map((record) => ({ file, record })),
-					),
+		return rows
+	})
+	const compact = Effect.scoped(
+		Effect.gen(function* () {
+			const rows = yield* read
+			const retained = Retention.retain(Array.map(rows, (row) => row.record))
+			const tokens = HashSet.fromIterable(
+				Array.map(retained, (record) => record.handle.token),
 			)
-			return rows
-		})
-		const compact = Effect.scoped(
-			Effect.gen(function* () {
-				const rows = yield* read
-				const retained = Retention.retain(Array.map(rows, (row) => row.record))
-				const tokens = HashSet.fromIterable(
-					Array.map(retained, (record) => record.handle.token),
+			const obsolete = Array.filter(
+				rows,
+				(row) => !HashSet.has(tokens, row.record.handle.token),
+			)
+			yield* Effect.forEach(
+				obsolete,
+				(row) =>
+					fs.remove(path.join(root, row.file)).pipe(Effect.uninterruptible),
+				{ discard: true },
+			)
+			if (obsolete.length > 0) {
+				const directory = yield* fs.open(root, { flag: "r" })
+				yield* directory.sync.pipe(Effect.uninterruptible)
+			}
+		}),
+	)
+	yield* storage(compact)
+	return Store.of({
+		list: storage(
+			mutex.withPermit(
+				read.pipe(Effect.map((rows) => Array.map(rows, (row) => row.record))),
+			),
+		),
+		save: Effect.fnUntraced(
+			function* (record: SessionRecord) {
+				const encoded = yield* Schema.encodeEffect(json)(record)
+				const address = yield* Schema.encodeEffect(
+					Schema.fromJsonString(
+						Schema.Struct({ key: Key, generation: Schema.Int }),
+					),
+				)({
+					key: record.handle.key,
+					generation: record.handle.generation,
+				})
+				const name = yield* digest.digestHex(
+					Digest.sha256,
+					new TextEncoder().encode(address),
 				)
-				const obsolete = Array.filter(
-					rows,
-					(row) => !HashSet.has(tokens, row.record.handle.token),
+				const nonce = yield* random.uuidV4()
+				const temporary = path.join(root, `.${name}.${nonce}.tmp`)
+				const destination = path.join(root, name + ".json")
+				yield* Effect.acquireRelease(
+					fs.open(temporary, { flag: "wx", mode: 0o600 }),
+					() => fs.remove(temporary, { force: true }).pipe(Effect.orDie),
+				).pipe(
+					Effect.flatMap((file) =>
+						file
+							.writeAll(new TextEncoder().encode(encoded))
+							.pipe(
+								Effect.uninterruptible,
+								Effect.andThen(file.sync.pipe(Effect.uninterruptible)),
+							),
+					),
 				)
-				yield* Effect.forEach(
-					obsolete,
-					(row) =>
-						fs.remove(path.join(root, row.file)).pipe(Effect.uninterruptible),
-					{ discard: true },
+				// Keep rename and directory synchronization together if the caller is canceled.
+				yield* Effect.uninterruptible(
+					Effect.gen(function* () {
+						yield* fs.rename(temporary, destination)
+						const directory = yield* fs.open(root, { flag: "r" })
+						yield* directory.sync.pipe(Effect.uninterruptible)
+					}),
 				)
-				if (obsolete.length > 0) {
-					const directory = yield* fs.open(root, { flag: "r" })
-					yield* directory.sync.pipe(Effect.uninterruptible)
-				}
-			}),
-		)
-		yield* storage(compact)
-		return Store.of({
-			list: storage(
-				mutex.withPermit(
-					read.pipe(Effect.map((rows) => Array.map(rows, (row) => row.record))),
-				),
-			),
-			save: (record) =>
-				storage(
-					mutex.withPermit(
-						Effect.scoped(
-							Effect.gen(function* () {
-								const encoded = yield* Schema.encodeEffect(json)(record)
-								const address = yield* Schema.encodeEffect(
-									Schema.fromJsonString(
-										Schema.Struct({ key: Key, generation: Schema.Int }),
-									),
-								)({
-									key: record.handle.key,
-									generation: record.handle.generation,
-								})
-								const name = yield* digest.digestHex(
-									Digest.sha256,
-									new TextEncoder().encode(address),
-								)
-								const nonce = yield* random.uuidV4()
-								const temporary = path.join(root, `.${name}.${nonce}.tmp`)
-								const destination = path.join(root, name + ".json")
-								yield* Effect.acquireRelease(
-									fs.open(temporary, { flag: "wx", mode: 0o600 }),
-									() =>
-										fs.remove(temporary, { force: true }).pipe(Effect.orDie),
-								).pipe(
-									Effect.flatMap((file) =>
-										file
-											.writeAll(new TextEncoder().encode(encoded))
-											.pipe(
-												Effect.uninterruptible,
-												Effect.andThen(file.sync.pipe(Effect.uninterruptible)),
-											),
-									),
-								)
-								// Keep rename and directory synchronization together if the caller is canceled.
-								yield* Effect.uninterruptible(
-									Effect.gen(function* () {
-										yield* fs.rename(temporary, destination)
-										const directory = yield* fs.open(root, { flag: "r" })
-										yield* directory.sync.pipe(Effect.uninterruptible)
-									}),
-								)
-								// The new high-water file is durable before any old record is removed.
-								yield* compact
-							}),
-						),
-					),
-				),
-		})
+				// The new high-water file is durable before any old record is removed.
+				yield* compact
+			},
+			Effect.scoped,
+			mutex.withPermit,
+			storage,
+		),
 	})
+})
 
 export const layerMemory = Layer.effect(Store, memory)
 export const layerDirectory = (root: string) =>