fix(artifacts): retain ASAR resources through cleanup failures

Give snapshot capture, header admission, packed members, and container streams one file-handle owner. Serialize adoption with reader shutdown, retain failed closes for retry, and remove snapshots only after descriptor cleanup succeeds.

Cover unread members, pending opens, zero-byte members, and paired format/cleanup failures. Keep intentionally unrecoverable test fixtures hygienic and strengthen managed identity and process cleanup-authority expectations.

Validation: full npm run check; 99 targeted tests and temporary-directory hygiene; exact discovery of 877 test files. No real vendor-provider verification was performed.
This commit is contained in:
morluto
2026-10-12 05:05:21 +08:00
parent 290d301ec7
commit eb97da3388
7 changed files with 670 additions and 222 deletions
+238 -110
View File
@@ -1,10 +1,4 @@
import {
constants,
createReadStream,
createWriteStream,
type ReadStream,
type Stats,
} from "node:fs";
import { constants, createWriteStream, type Stats } from "node:fs";
import {
lstat,
mkdtemp,
@@ -46,51 +40,40 @@ export class AsarArtifactReader implements ArtifactReader {
#archiveSize: number | undefined;
#headerSize: number | undefined;
readonly #entries = new Map<string, AsarEntryState>();
readonly #unpackedHandles = new Map<
UnpackedFileHandle,
{
readonly path: string;
readonly owner: OwnedFileHandle<UnpackedFileHandle>;
}
>();
readonly #ownedHandles = new Map<SharedAsarFileHandle, OwnedAsarHandle>();
#snapshot: { readonly path: string; readonly sha256: string } | undefined;
#snapshotRoot: string | undefined;
#snapshotOperation: Promise<void> = Promise.resolve();
constructor(
private readonly path: string,
private readonly openUnpackedFile: OpenAsarUnpackedFile = open,
private readonly removeSnapshot: (path: string) => Promise<void> = (path) =>
rm(path, { recursive: true, force: true }),
private readonly options: AsarArtifactReaderOptions = {},
) {}
async *entries(signal?: AbortSignal): AsyncIterable<ArtifactEntry> {
let paths: readonly AsarListedPath[];
try {
await this.prepareContainer(undefined, signal);
const snapshotPath = this.#snapshotPath();
this.#resetArchiveState();
this.#entries.clear();
const headerHandle = await open(
snapshotPath,
constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK,
);
try {
const admitted = await admitAsarHeader(headerHandle);
paths = await this.#withSnapshotOperation(async () => {
const snapshotPath = this.#snapshotPath();
this.#resetArchiveState();
this.#entries.clear();
const admitted = await this.#admitHeader(snapshotPath);
this.#archiveSize = admitted.archiveBytes;
this.#headerSize = admitted.headerBytes;
} finally {
await headerHandle.close();
}
abortIfNeeded(signal);
paths = orderAsarListing(listPackage(snapshotPath, { isPack: false }));
const archiveMetadata = await lstat(snapshotPath);
if (!archiveMetadata.isFile() || archiveMetadata.isSymbolicLink())
throw new ArtifactReaderFailure(
"format",
"ASAR container is not a regular file",
abortIfNeeded(signal);
const ordered = orderAsarListing(
listPackage(snapshotPath, { isPack: false }),
);
this.#archiveSize = archiveMetadata.size;
const archiveMetadata = await lstat(snapshotPath);
if (!archiveMetadata.isFile() || archiveMetadata.isSymbolicLink())
throw new ArtifactReaderFailure(
"format",
"ASAR container is not a regular file",
);
this.#archiveSize = archiveMetadata.size;
return ordered;
}, signal);
} catch (cause: unknown) {
throw asarFailure(this.path, "inventory", cause);
}
@@ -142,7 +125,47 @@ export class AsarArtifactReader implements ArtifactReader {
}
}
async #admitHeader(snapshotPath: string) {
const headerHandle = await this.#openOwned(
snapshotPath,
constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK,
);
let admission:
| {
readonly ok: true;
readonly value: Awaited<ReturnType<typeof admitAsarHeader>>;
}
| { readonly ok: false; readonly cause: unknown };
try {
admission = { ok: true, value: await admitAsarHeader(headerHandle) };
} catch (cause: unknown) {
admission = { ok: false, cause };
}
try {
await this.#closeOwnedHandle(headerHandle);
} catch (cleanupCause: unknown) {
if (!admission.ok)
throw ArtifactReaderFailure.withCleanup(
admission.cause,
ArtifactReaderFailure.cleanupObservation(cleanupCause, snapshotPath),
);
throw cleanupCause;
}
if (!admission.ok) throw admission.cause;
return admission.value;
}
async open(entry: ArtifactEntry, signal?: AbortSignal): Promise<Readable> {
return this.#withSnapshotOperation(
() => this.#openEntry(entry, signal),
signal,
);
}
async #openEntry(
entry: ArtifactEntry,
signal?: AbortSignal,
): Promise<Readable> {
abortIfNeeded(signal);
const state = this.#entries.get(entry.adapterKey);
if (state === undefined && entry.kind !== "file")
@@ -160,10 +183,16 @@ export class AsarArtifactReader implements ArtifactReader {
"integrity",
`ASAR entry metadata changed since inventory: ${state.entry.path}`,
);
const { metadata } = state;
const producedEntry = state.entry;
if (producedEntry.unpacked)
return this.#openUnpackedStream(producedEntry, signal);
if (state.entry.unpacked)
return this.#openUnpackedStream(state.entry, signal);
return this.#openPackedStream(state, signal);
}
async #openPackedStream(
state: AsarEntryState,
signal?: AbortSignal,
): Promise<Readable> {
const { metadata, entry: producedEntry } = state;
const archiveSize = this.#archiveSize;
const headerSize = this.#headerSize;
const offset =
@@ -187,10 +216,11 @@ export class AsarArtifactReader implements ArtifactReader {
"format",
`ASAR entry range is outside its container: ${producedEntry.path}`,
);
let handle: FileHandle | undefined;
const snapshotPath = this.#snapshotPath();
let handle: SharedAsarFileHandle | undefined;
try {
const openedHandle = await open(
this.#snapshotPath(),
const openedHandle = await this.#openOwned(
snapshotPath,
constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK,
);
handle = openedHandle;
@@ -202,25 +232,48 @@ export class AsarArtifactReader implements ArtifactReader {
`ASAR container changed before read: ${producedEntry.path}`,
);
if (metadata.size === 0) {
await closeAsarHandle(() => openedHandle.close(), signal);
handle = undefined;
await closeAsarHandle(
() => this.#closeOwnedHandle(openedHandle),
signal,
);
return Readable.from([]);
}
const source = openedHandle.createReadStream({
const source = this.#ownedReadStream(openedHandle, {
start,
end: start + metadata.size - 1,
autoClose: true,
signal,
});
return readValidatedAsarEntry(
handle = undefined;
const output = readValidatedAsarEntry(
source,
metadata.size,
producedEntry.path,
this.path,
signal,
);
this.#setOwnedOutput(openedHandle, output);
return output;
} catch (cause: unknown) {
await handle?.close().catch(() => undefined);
throw asarFailure(this.path, `read ${producedEntry.path}`, cause);
const failure = asarFailure(
this.path,
`read ${producedEntry.path}`,
cause,
);
if (handle !== undefined) {
try {
await this.#closeOwnedHandle(handle);
} catch (cleanupCause: unknown) {
throw ArtifactReaderFailure.withCleanup(
failure,
ArtifactReaderFailure.cleanupObservation(
cleanupCause,
snapshotPath,
),
);
}
}
throw failure;
}
}
@@ -246,49 +299,37 @@ export class AsarArtifactReader implements ArtifactReader {
}
/** Read the same captured container that supplies headers and packed members. */
async openContainer(signal?: AbortSignal): Promise<ReadStream> {
async openContainer(signal?: AbortSignal): Promise<Readable> {
await this.prepareContainer(undefined, signal);
return createReadStream(
this.#snapshotPath(),
signal === undefined ? {} : { signal },
);
return this.#withSnapshotOperation(async () => {
abortIfNeeded(signal);
const snapshotPath = this.#snapshotPath();
const handle = await this.#openOwned(
snapshotPath,
constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK,
);
return this.#ownedReadStream(handle, { signal });
}, signal);
}
async close(): Promise<void> {
await this.#withSnapshotOperation(async () => {
let cleanupFailure: ArtifactReaderFailure | undefined;
for (const [handle, { path }] of this.#unpackedHandles) {
try {
await this.#closeUnpackedHandle(handle);
} catch (cause: unknown) {
cleanupFailure = ArtifactReaderFailure.withCleanup(
cleanupFailure ?? cause,
ArtifactReaderFailure.cleanupObservation(cause, path),
);
}
}
try {
await this.#closeSnapshot();
} catch (cause: unknown) {
cleanupFailure = ArtifactReaderFailure.withCleanup(
cleanupFailure ?? cause,
ArtifactReaderFailure.cleanupObservation(cause, this.path),
);
}
if (cleanupFailure !== undefined) throw cleanupFailure;
});
await this.#withSnapshotOperation(() => this.#closeSnapshot());
}
async #captureSnapshot(signal?: AbortSignal): Promise<void> {
let inputHandle: SharedAsarFileHandle | undefined;
try {
this.#snapshotRoot = await mkdtemp(join(tmpdir(), "rea-asar-snapshot-"));
const snapshotPath = join(this.#snapshotRoot, "container.asar");
const hash = createHash("sha256");
const handle = await open(
inputHandle = await this.#openOwned(
this.path,
constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK,
);
const source = handle.createReadStream();
const source = this.#ownedReadStream(inputHandle, {
signal,
releaseOnClose: false,
});
const digesting = new Transform({
transform(chunk: Buffer, _encoding, callback) {
hash.update(chunk);
@@ -301,34 +342,50 @@ export class AsarArtifactReader implements ArtifactReader {
createWriteStream(snapshotPath, { flags: "wx", mode: 0o600 }),
signal === undefined ? {} : { signal },
);
const completedInput = inputHandle;
inputHandle = undefined;
await this.#closeOwnedHandle(completedInput);
this.#snapshot = { path: snapshotPath, sha256: hash.digest("hex") };
} catch (cause: unknown) {
const primary =
let failure =
signal?.aborted === true
? new ArtifactReaderFailure("cancelled", "ASAR operation cancelled", {
cause,
})
: asarFailure(this.path, "snapshot", cause);
if (inputHandle !== undefined) {
const failedInput = inputHandle;
inputHandle = undefined;
try {
await this.#closeOwnedHandle(failedInput);
} catch (cleanupCause: unknown) {
failure = ArtifactReaderFailure.withCleanup(
failure,
ArtifactReaderFailure.cleanupObservation(cleanupCause, this.path),
);
}
}
try {
await this.#closeSnapshot();
if (this.#ownedHandles.size === 0) await this.#closeSnapshot();
} catch (cleanupCause: unknown) {
throw ArtifactReaderFailure.withCleanup(
primary,
failure,
ArtifactReaderFailure.cleanupObservation(
cleanupCause,
this.#snapshotRoot ?? this.path,
),
);
}
throw primary;
throw failure;
}
}
async #closeSnapshot(): Promise<void> {
await this.#closeOwnedHandles();
const root = this.#snapshotRoot;
if (root !== undefined) {
try {
await this.removeSnapshot(root);
await (this.options.removeSnapshot ?? defaultRemoveSnapshot)(root);
if (this.#snapshotRoot === root) this.#snapshotRoot = undefined;
} catch (cause: unknown) {
throw ArtifactReaderFailure.withCleanup(cause, {
@@ -386,7 +443,7 @@ export class AsarArtifactReader implements ArtifactReader {
signal?: AbortSignal,
): Promise<Readable> {
const unpackedRoot = `${this.path}.unpacked`;
let handle: UnpackedFileHandle | undefined;
let handle: SharedAsarFileHandle | undefined;
try {
const rootMetadata = await lstat(unpackedRoot);
if (!rootMetadata.isDirectory() || rootMetadata.isSymbolicLink())
@@ -413,15 +470,12 @@ export class AsarArtifactReader implements ArtifactReader {
"path",
`ASAR unpacked entry is not a regular file: ${entry.path}`,
);
handle = await this.openUnpackedFile(
handle = await (this.options.openUnpackedFile ?? open)(
canonical,
constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK,
);
const openedHandle = handle;
this.#unpackedHandles.set(openedHandle, {
path: canonical,
owner: new OwnedFileHandle(openedHandle),
});
this.#adoptHandle(openedHandle, canonical);
const openedMetadata = await openedHandle.stat();
if (
!openedMetadata.isFile() ||
@@ -441,30 +495,28 @@ export class AsarArtifactReader implements ArtifactReader {
);
}
abortIfNeeded(signal);
const source = readFileHandleChunks(openedHandle, {
start: 0,
});
source.once("close", () => {
void this.#closeUnpackedHandle(openedHandle).catch(() => undefined);
});
return readValidatedAsarEntry(
const source = this.#ownedReadStream(openedHandle, { start: 0 });
handle = undefined;
const output = readValidatedAsarEntry(
source,
undefined,
entry.path,
this.path,
signal,
);
this.#setOwnedOutput(openedHandle, output);
return output;
} catch (cause: unknown) {
let failure = asarUnpackedEntryFailure(this.path, entry, cause);
if (handle !== undefined && this.#unpackedHandles.has(handle)) {
if (handle !== undefined && this.#ownedHandles.has(handle)) {
try {
await this.#closeUnpackedHandle(handle);
await this.#closeOwnedHandle(handle);
} catch (cleanupCause: unknown) {
failure = ArtifactReaderFailure.withCleanup(
failure,
ArtifactReaderFailure.cleanupObservation(
cleanupCause,
this.#unpackedHandles.get(handle)?.path ?? entry.path,
this.#ownedHandles.get(handle)?.path ?? entry.path,
),
);
}
@@ -473,11 +525,76 @@ export class AsarArtifactReader implements ArtifactReader {
}
}
async #closeUnpackedHandle(handle: UnpackedFileHandle): Promise<void> {
const owned = this.#unpackedHandles.get(handle);
async #closeOwnedHandle(handle: SharedAsarFileHandle): Promise<void> {
const owned = this.#ownedHandles.get(handle);
if (owned === undefined) return;
await owned.owner.close();
this.#unpackedHandles.delete(handle);
owned.output?.destroy();
owned.source?.destroy();
try {
await owned.owner.close();
} catch (cause: unknown) {
throw ArtifactReaderFailure.withCleanup(
cause,
ArtifactReaderFailure.cleanupObservation(cause, owned.path),
);
}
this.#ownedHandles.delete(handle);
}
async #closeOwnedHandles(): Promise<void> {
let failure: ArtifactReaderFailure | undefined;
for (const [handle, owned] of this.#ownedHandles) {
try {
await this.#closeOwnedHandle(handle);
} catch (cause: unknown) {
failure = ArtifactReaderFailure.withCleanup(
failure ?? cause,
ArtifactReaderFailure.cleanupObservation(cause, owned.path),
);
}
}
if (failure !== undefined) throw failure;
}
async #openOwned(path: string, flags: number): Promise<SharedAsarFileHandle> {
const handle = await (this.options.openFile ?? open)(path, flags);
this.#adoptHandle(handle, path);
return handle;
}
#adoptHandle(handle: SharedAsarFileHandle, path: string): void {
this.#ownedHandles.set(handle, {
path,
owner: new OwnedFileHandle(handle),
});
}
#ownedReadStream(
handle: SharedAsarFileHandle,
options: {
readonly start?: number;
readonly end?: number;
readonly signal?: AbortSignal | undefined;
readonly releaseOnClose?: boolean;
},
): Readable {
const { releaseOnClose, ...readOptions } = options;
const source = readFileHandleChunks(handle, readOptions);
const owned = this.#ownedHandles.get(handle);
if (owned === undefined)
throw new ArtifactReaderFailure("integrity", "ASAR handle has no owner");
owned.source = source;
owned.output = source;
if (releaseOnClose !== false)
source.once("close", () => {
void this.#closeOwnedHandle(handle).catch(() => undefined);
});
return source;
}
#setOwnedOutput(handle: SharedAsarFileHandle, output: Readable): void {
const owned = this.#ownedHandles.get(handle);
if (owned !== undefined) owned.output = output;
}
#resetArchiveState(): void {
@@ -491,16 +608,27 @@ type AsarEntryState = {
readonly metadata: AsarFileMetadata;
readonly entry: ArtifactEntry;
};
type UnpackedFileHandle = {
readonly fd: number;
type SharedAsarFileHandle = Pick<FileHandle, "fd" | "read" | "close"> & {
stat(): Promise<Stats>;
close(): Promise<void>;
read: FileHandle["read"];
};
type OpenAsarUnpackedFile = (
type OpenAsarFile = (
path: string,
flags: number,
) => Promise<UnpackedFileHandle>;
) => Promise<SharedAsarFileHandle>;
type OwnedAsarHandle = {
readonly path: string;
readonly owner: OwnedFileHandle<SharedAsarFileHandle>;
source?: Readable;
output?: Readable;
};
type AsarArtifactReaderOptions = {
readonly openFile?: OpenAsarFile;
readonly openUnpackedFile?: OpenAsarFile;
readonly removeSnapshot?: (path: string) => Promise<void>;
};
const defaultRemoveSnapshot = (path: string): Promise<void> =>
rm(path, { recursive: true, force: true });
const asarUnpackedEntryFailure = (
archivePath: string,
+2 -1
View File
@@ -1,3 +1,4 @@
import type { Stats } from "node:fs";
import type { FileHandle } from "node:fs/promises";
import { ArtifactReaderFailure } from "./ArtifactReader.js";
@@ -7,7 +8,7 @@ export const MAX_ASAR_HEADER_BYTES = 16 * 1024 * 1024;
/** Admit both Chromium pickle extents before an upstream decoder allocates them. */
export const admitAsarHeader = async (
handle: FileHandle,
handle: Pick<FileHandle, "read"> & { stat(): Promise<Stats> },
): Promise<{
readonly archiveBytes: number;
readonly headerBytes: number;
@@ -280,7 +280,11 @@ describe("managed native boundary inspection", () => {
describe("independent managed metadata facets", () => {
it("preserves identity, members, and imports when embedded resources are malformed", () => {
const bytes = buildManagedPeFixture({ pinvoke: {}, readyToRun: true });
const bytes = buildManagedPeFixture({
mvid: Buffer.from("3aebc60edc4a544b1f458b4ed40b33b1", "hex"),
pinvoke: {},
readyToRun: true,
});
bytes.writeUInt32LE(0x7fff_0000, 0x0200 + 24);
const target = managedPeFixtureTarget(bytes);
const artifact = inspectManagedArtifactBytes(bytes, target);
@@ -288,7 +292,7 @@ describe("independent managed metadata facets", () => {
const native = inspectManagedNativeBoundariesBytes(bytes, target);
for (const result of [artifact, members, native]) {
expect(result.module?.mvid).toBeTruthy();
expect(result.module?.mvid).toBe("0ec6eb3a-4adc-4b54-1f45-8b4ed40b33b1");
expect(result.metadata.status).toBe("partial");
expect(result.coverage).toMatchObject({
state: "partial",
@@ -182,15 +182,13 @@ describe("ASAR snapshot operation ownership", () => {
const removalStartedPromise = new Promise<void>((resolve) => {
removalStarted = resolve;
});
const reader = new AsarArtifactReader(
fixture.archive,
undefined,
async (path) => {
const reader = new AsarArtifactReader(fixture.archive, {
removeSnapshot: async (path) => {
removalStarted?.();
await removalGate;
await rm(path, { recursive: true, force: true });
},
);
});
let prepared = false;
const preparing = reader.prepareContainer().then(() => {
prepared = true;
@@ -302,15 +300,13 @@ describe("ASAR captured-byte identity", () => {
it("retains a completed inventory and snapshot ownership when cleanup fails", async () => {
const fixture = await archiveFixture();
const attempts: string[] = [];
const reader = new AsarArtifactReader(
fixture.archive,
undefined,
async (path) => {
const reader = new AsarArtifactReader(fixture.archive, {
removeSnapshot: async (path) => {
attempts.push(path);
if (attempts.length === 1) throw new Error("snapshot removal denied");
await rm(path, { recursive: true, force: true });
},
);
});
const resourceScope = new ArtifactResourceScope();
onTestFinished(() => resourceScope.close());
try {
@@ -0,0 +1,266 @@
import { fstatSync } from "node:fs";
import {
lstat,
mkdir,
open as openFile,
type FileHandle,
writeFile,
} from "node:fs/promises";
import { dirname, join } from "node:path";
import { createPackage } from "@electron/asar";
import { describe, expect, it } from "vitest";
import { AsarArtifactReader } from "../../../src/artifacts/AsarArtifactReader.js";
import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";
const CONTENT = "module.exports = 'owned';\n";
const createArchive = async (content = CONTENT) => {
const root = await createTestTempDirectory("rea-asar-reader-cleanup-");
const source = join(root, "source");
const archive = join(root, "fixture.asar");
await mkdir(source);
await writeFile(join(source, "main.js"), content);
await createPackage(source, archive);
return { archive };
};
type OpenedHandle = { readonly path: string; readonly fd: number };
type ReaderHooks = {
readonly beforeAdoption?: (path: string, handle: FileHandle) => Promise<void>;
readonly close?: (handle: FileHandle) => Promise<void>;
};
const createTrackedReader = (archive: string, hooks: ReaderHooks = {}) => {
const opened: OpenedHandle[] = [];
const reader = new AsarArtifactReader(archive, {
openFile: async (path, flags) => {
const handle = await openFile(path, flags);
opened.push({ path, fd: handle.fd });
await hooks.beforeAdoption?.(path, handle);
return {
get fd() {
return handle.fd;
},
stat: () => handle.stat(),
read: handle.read.bind(handle),
close: () => hooks.close?.(handle) ?? handle.close(),
};
},
});
return { reader, opened };
};
const packedMember = async (reader: AsarArtifactReader) => {
for await (const entry of reader.entries())
if (entry.path === "main.js") return entry;
throw new Error("Expected packed ASAR member");
};
const latestHandle = (opened: readonly OpenedHandle[]): OpenedHandle => {
const handle = opened.at(-1);
if (handle === undefined)
throw new Error("Expected a descriptor for the packed member");
return handle;
};
const openPackedMember = async (
reader: AsarArtifactReader,
opened: readonly OpenedHandle[],
) => {
const output = await reader.open(await packedMember(reader));
const handle = latestHandle(opened);
return { output, handle, root: dirname(handle.path) };
};
const expectDescriptorOpen = (fd: number): void => {
expect(fstatSync(fd).isFile()).toBe(true);
};
const expectDescriptorClosed = (fd: number): void => {
expect(() => fstatSync(fd)).toThrow();
};
const expectSnapshotRemoved = async (
fd: number,
root: string,
): Promise<void> => {
expectDescriptorClosed(fd);
await expect(lstat(root)).rejects.toMatchObject({ code: "ENOENT" });
};
describe("ASAR reader cleanup", () => {
it("reaps an unread packed member and its snapshot when the reader closes", async () => {
const { archive } = await createArchive();
const { reader, opened } = createTrackedReader(archive);
try {
const {
output,
handle: memberHandle,
root,
} = await openPackedMember(reader, opened);
expect(memberHandle.path).toContain("rea-asar-snapshot-");
expectDescriptorOpen(memberHandle.fd);
expect(output.destroyed).toBe(false);
await reader.close();
await expectSnapshotRemoved(memberHandle.fd, root);
} finally {
await reader.close();
}
});
it("retains the snapshot and facts after a failed close, then retries cleanup", async () => {
const { archive } = await createArchive();
let failNextClose = false;
const closeFailure = Object.assign(new Error("injected close failure"), {
code: "EIO",
errno: -5,
syscall: "close",
});
const { reader, opened } = createTrackedReader(archive, {
close: async (handle) => {
if (failNextClose) {
failNextClose = false;
throw closeFailure;
}
await handle.close();
},
});
try {
const { handle: memberHandle, root } = await openPackedMember(
reader,
opened,
);
failNextClose = true;
await expect(reader.close()).rejects.toMatchObject({
cleanup: { resources: [memberHandle.path] },
});
expectDescriptorOpen(memberHandle.fd);
expect((await lstat(root)).isDirectory()).toBe(true);
expect(await packedMember(reader)).toMatchObject({ path: "main.js" });
await reader.close();
await expectSnapshotRemoved(memberHandle.fd, root);
} finally {
await reader.close();
}
});
it("closes a member handle adopted while reader shutdown is queued", async () => {
const { archive } = await createArchive();
let pauseMemberOpen = false;
let memberOpenReached!: () => void;
let releaseMemberOpen!: () => void;
const memberOpenStarted = new Promise<void>((resolve) => {
memberOpenReached = resolve;
});
const memberOpenGate = new Promise<void>((resolve) => {
releaseMemberOpen = resolve;
});
const { reader, opened } = createTrackedReader(archive, {
beforeAdoption: async (path) => {
if (pauseMemberOpen && path.includes("rea-asar-snapshot-")) {
pauseMemberOpen = false;
memberOpenReached();
await memberOpenGate;
}
},
});
try {
const entry = await packedMember(reader);
pauseMemberOpen = true;
const opening = reader.open(entry);
await memberOpenStarted;
const closing = reader.close();
releaseMemberOpen();
const output = await opening;
const memberHandle = latestHandle(opened);
const root = dirname(memberHandle.path);
await closing;
expect(output.destroyed).toBe(true);
await expectSnapshotRemoved(memberHandle.fd, root);
} finally {
releaseMemberOpen();
await reader.close();
}
});
});
describe("ASAR preparation cleanup", () => {
it("retains a zero-byte member handle when its first close fails", async () => {
const { archive } = await createArchive("");
let failNextClose = false;
const { reader, opened } = createTrackedReader(archive, {
close: async (handle) => {
if (failNextClose) {
failNextClose = false;
throw new Error("empty member close denied");
}
await handle.close();
},
});
try {
const entry = await packedMember(reader);
failNextClose = true;
await expect(reader.open(entry)).rejects.toMatchObject({
cleanup: {
reason: "empty member close denied",
resources: [expect.any(String)],
},
});
const handle = latestHandle(opened);
expectDescriptorOpen(handle.fd);
expect((await lstat(dirname(handle.path))).isDirectory()).toBe(true);
await reader.close();
await expectSnapshotRemoved(handle.fd, dirname(handle.path));
} finally {
await reader.close();
}
});
it("preserves a malformed header failure when closing its handle also fails", async () => {
const { archive } = await createArchive();
await writeFile(archive, Buffer.alloc(16));
let failHeaderClose = false;
const closeFailure = new Error("header close denied");
const { reader, opened } = createTrackedReader(archive, {
beforeAdoption: async (path) => {
if (path !== archive) failHeaderClose = true;
},
close: async (handle) => {
if (failHeaderClose) {
failHeaderClose = false;
throw closeFailure;
}
await handle.close();
},
});
try {
await expect(packedMember(reader)).rejects.toMatchObject({
reason: "format",
message: "Truncated or invalid ASAR size pickle",
cleanup: {
reason: closeFailure.message,
resources: [expect.any(String)],
},
});
const handle = latestHandle(opened);
expectDescriptorOpen(handle.fd);
expect((await lstat(dirname(handle.path))).isDirectory()).toBe(true);
await reader.close();
await expectSnapshotRemoved(handle.fd, dirname(handle.path));
} finally {
await reader.close();
}
});
});
@@ -9,11 +9,11 @@ import {
writeFile,
truncate,
} from "node:fs/promises";
import { join } from "node:path";
import { dirname, join } from "node:path";
import { Readable } from "node:stream";
import { buffer } from "node:stream/consumers";
import { createPackageWithOptions } from "@electron/asar";
import { describe, expect, it } from "vitest";
import { describe, expect, it, onTestFinished } from "vitest";
import { scanArtifactInventory } from "../../fixtures/artifactInventory.js";
import { AsarArtifactReader } from "../../../src/artifacts/AsarArtifactReader.js";
import {
@@ -105,7 +105,13 @@ describe("ASAR entry streaming", () => {
await writeFile(join(source, "small.js"), "module.exports = 1;\n");
await createPackageWithOptions(source, archive, {});
const reader = new AsarArtifactReader(archive);
let snapshotPath: string | undefined;
const reader = new AsarArtifactReader(archive, {
openFile: async (path, flags) => {
if (path !== archive) snapshotPath = path;
return openFile(path, flags);
},
});
try {
const entries = [];
@@ -115,9 +121,11 @@ describe("ASAR entry streaming", () => {
const entry = entries.find(({ path }) => path === "small.js");
if (entry === undefined) throw new Error("Expected packed ASAR member");
const snapshot = await reader.openContainer();
const identity = await lstat(snapshot.path);
if (snapshotPath === undefined)
throw new Error("Expected snapshot acquisition");
const identity = await lstat(snapshotPath);
await buffer(snapshot);
const probe = await openFile(snapshot.path, "r");
const probe = await openFile(snapshotPath, "r");
expect(await matchingDescriptorCount(identity)).toBeGreaterThan(0);
await probe.close();
expect(await matchingDescriptorCount(identity)).toBe(0);
@@ -145,7 +153,13 @@ describe("ASAR entry streaming", () => {
await writeFile(join(source, "small.js"), "module.exports = 1;\n");
await createPackageWithOptions(source, archive, {});
const reader = new AsarArtifactReader(archive);
let snapshotPath: string | undefined;
const reader = new AsarArtifactReader(archive, {
openFile: async (path, flags) => {
if (path !== archive) snapshotPath = path;
return openFile(path, flags);
},
});
try {
const entries = [];
@@ -153,7 +167,9 @@ describe("ASAR entry streaming", () => {
const entry = entries.find(({ path }) => path === "small.js");
if (entry === undefined) throw new Error("Expected packed ASAR member");
const snapshot = await reader.openContainer();
const identity = await lstat(snapshot.path);
if (snapshotPath === undefined)
throw new Error("Expected snapshot acquisition");
const identity = await lstat(snapshotPath);
await buffer(snapshot);
const controller = new AbortController();
const opening = reader.open(entry, controller.signal);
@@ -340,23 +356,25 @@ describe("ASAR read failures", () => {
syscall: "close",
});
let closeCount = 0;
const reader = new AsarArtifactReader(archive, async (path, flags) => {
const handle = await openFile(path, flags);
expect(await matchingDescriptorCount(identity)).toBeGreaterThan(0);
return {
get fd() {
return handle.fd;
},
async stat() {
throw ioError;
},
async close() {
closeCount += 1;
if (closeCount === 1) throw closeError;
await handle.close();
},
read: handle.read.bind(handle),
};
const reader = new AsarArtifactReader(archive, {
openUnpackedFile: async (path, flags) => {
const handle = await openFile(path, flags);
expect(await matchingDescriptorCount(identity)).toBeGreaterThan(0);
return {
get fd() {
return handle.fd;
},
async stat() {
throw ioError;
},
async close() {
closeCount += 1;
if (closeCount === 1) throw closeError;
await handle.close();
},
read: handle.read.bind(handle),
};
},
});
try {
@@ -396,24 +414,37 @@ it.skipIf(process.platform === "win32")(
});
const closeFailure = new Error("native close outcome unavailable");
let closeCount = 0;
const reader = new AsarArtifactReader(archive, async (path, flags) => {
const handle = await openFile(path, flags);
return {
get fd() {
return handle.fd;
},
async stat() {
throw statFailure;
},
async close() {
closeCount += 1;
// Model Node's invalidated-descriptor rejection without leaking a
// native descriptor in the test process.
await handle.close();
throw closeFailure;
},
read: handle.read.bind(handle),
};
let snapshotRoot: string | undefined;
const reader = new AsarArtifactReader(archive, {
openFile: async (path, flags) => {
if (path !== archive && snapshotRoot === undefined) {
const root = dirname(path);
snapshotRoot = root;
// This fixture deliberately reports an unrecoverable close outcome.
// Remove its retained snapshot only after testing reader ownership.
onTestFinished(() => rm(root, { recursive: true, force: true }));
}
return openFile(path, flags);
},
openUnpackedFile: async (path, flags) => {
const handle = await openFile(path, flags);
return {
get fd() {
return handle.fd;
},
async stat() {
throw statFailure;
},
async close() {
closeCount += 1;
// Model Node's invalidated-descriptor rejection without leaking a
// native descriptor in the test process.
await handle.close();
throw closeFailure;
},
read: handle.read.bind(handle),
};
},
});
const entry = await unpackedMember(reader);
await expect(reader.open(entry)).rejects.toMatchObject({
@@ -430,6 +461,8 @@ it.skipIf(process.platform === "win32")(
});
expect(closeCount).toBe(1);
await waitForNoMatchingDescriptor(identity);
if (snapshotRoot === undefined) throw new Error("Expected ASAR snapshot");
expect((await lstat(snapshotRoot)).isDirectory()).toBe(true);
},
);
@@ -439,24 +472,26 @@ it.skipIf(process.platform === "win32")(
const { archive, unpackedPath, identity } = await createUnpackedFixture();
const controller = new AbortController();
let closeCount = 0;
const reader = new AsarArtifactReader(archive, async (path, flags) => {
const handle = await openFile(path, flags);
return {
get fd() {
return handle.fd;
},
async stat() {
const observed = await handle.stat();
controller.abort();
return observed;
},
async close() {
closeCount += 1;
if (closeCount === 1) throw new Error("first close failed");
await handle.close();
},
read: handle.read.bind(handle),
};
const reader = new AsarArtifactReader(archive, {
openUnpackedFile: async (path, flags) => {
const handle = await openFile(path, flags);
return {
get fd() {
return handle.fd;
},
async stat() {
const observed = await handle.stat();
controller.abort();
return observed;
},
async close() {
closeCount += 1;
if (closeCount === 1) throw new Error("first close failed");
await handle.close();
},
read: handle.read.bind(handle),
};
},
});
try {
@@ -484,25 +519,27 @@ it.skipIf(process.platform === "win32")(
const { archive, unpackedPath, identity } = await createUnpackedFixture();
const closeError = new Error("first close failed");
let closeCount = 0;
const reader = new AsarArtifactReader(archive, async (path, flags) => {
const handle = await openFile(path, flags);
return {
get fd() {
return handle.fd;
},
async stat() {
const observed = await handle.stat();
return Object.assign(Object.create(observed), {
ino: observed.ino + 1,
});
},
async close() {
closeCount += 1;
if (closeCount === 1) throw closeError;
await handle.close();
},
read: handle.read.bind(handle),
};
const reader = new AsarArtifactReader(archive, {
openUnpackedFile: async (path, flags) => {
const handle = await openFile(path, flags);
return {
get fd() {
return handle.fd;
},
async stat() {
const observed = await handle.stat();
return Object.assign(Object.create(observed), {
ino: observed.ino + 1,
});
},
async close() {
closeCount += 1;
if (closeCount === 1) throw closeError;
await handle.close();
},
read: handle.read.bind(handle),
};
},
});
try {
@@ -527,16 +564,15 @@ it.skipIf(process.platform === "win32")(
);
it.skipIf(process.platform === "win32")(
"retains unpacked handles and snapshots across combined cleanup failures",
"retains unpacked handles before retrying snapshot cleanup failures",
async () => {
const { archive, unpackedPath, identity } = await createUnpackedFixture();
const closeError = new Error("unpacked close denied");
const snapshotError = new Error("snapshot removal denied");
let closeCount = 0;
const snapshotPaths: string[] = [];
const reader = new AsarArtifactReader(
archive,
async (path, flags) => {
const reader = new AsarArtifactReader(archive, {
openUnpackedFile: async (path, flags) => {
const handle = await openFile(path, flags);
return {
get fd() {
@@ -557,12 +593,12 @@ it.skipIf(process.platform === "win32")(
read: handle.read.bind(handle),
};
},
async (path) => {
removeSnapshot: async (path) => {
snapshotPaths.push(path);
if (snapshotPaths.length === 1) throw snapshotError;
await rm(path, { recursive: true, force: true });
},
);
});
try {
const entry = await unpackedMember(reader);
@@ -579,19 +615,24 @@ it.skipIf(process.platform === "win32")(
);
expect(cleanupFailure).toMatchObject({
cleanup: {
resources: [unpackedPath, expect.any(String)],
resources: [unpackedPath],
reason: expect.stringContaining("unpacked close denied"),
},
});
expect(closeCount).toBe(2);
expect(snapshotPaths).toEqual([]);
expect(await matchingDescriptorCount(identity)).toBeGreaterThan(0);
await expect(reader.close()).rejects.toMatchObject({
message: snapshotError.message,
cleanup: { resources: [expect.any(String)] },
});
expect(closeCount).toBe(3);
await waitForNoMatchingDescriptor(identity);
const snapshotRoot = snapshotPaths[0];
if (snapshotRoot === undefined)
throw new Error("Expected owned ASAR snapshot root");
expect(snapshotPaths).toEqual([snapshotRoot]);
expect(cleanupFailure).toMatchObject({
cleanup: { resources: [unpackedPath, snapshotRoot] },
});
expect(closeCount).toBe(2);
expect(await matchingDescriptorCount(identity)).toBeGreaterThan(0);
expect((await lstat(snapshotRoot)).isDirectory()).toBe(true);
await reader.close();
+20 -8
View File
@@ -285,12 +285,17 @@ describe("provider process output and cleanup primitives", () => {
await stopProviderProcessFixture(child);
}
});
});
describe("provider process cleanup authority", () => {
it("honors verified group cleanup instead of direct process signaling", async () => {
const child = spawnProviderProcessFixture("stubborn");
await waitForProviderProcessReady(child);
const signalFromCleanup = child.kill.bind(child);
const directSignal = vi.spyOn(child, "kill");
const cleanup = vi.fn(async () => {
child.kill("SIGKILL");
// Keep the injected cleanup signal separate from the supervisor's
// direct method, while retaining the child handle's lifetime checks.
signalFromCleanup("SIGKILL");
return { cleaned: true, signaled: true } as const;
});
const supervisor = new ProviderProcessSupervisor({
@@ -299,12 +304,19 @@ describe("provider process output and cleanup primitives", () => {
cleanup,
});
await expect(supervisor.stop({ killGraceMs: 500 })).resolves.toEqual({
status: "verified-cleanup",
});
// Cleanup must be attempted. The exact attempt count is an internal retry
// ladder, so it is deliberately not pinned here.
expect(cleanup).toHaveBeenCalled();
try {
await waitForProviderProcessReady(child);
await expect(supervisor.stop({ killGraceMs: 500 })).resolves.toEqual({
status: "verified-cleanup",
});
// Cleanup must be attempted. The exact attempt count is an internal
// retry ladder, so it is deliberately not pinned here.
expect(cleanup).toHaveBeenCalled();
expect(directSignal).not.toHaveBeenCalled();
} finally {
directSignal.mockRestore();
await stopProviderProcessFixture(child);
}
});
it("cleans an owned group even after its launcher leader has exited", async () => {