fix(binary): retain unconfirmed composite clients until close succeeds (#12599)

* fix(binary): retain unconfirmed composite clients until close succeeds

* fix(binary): settle synthesized close failures after client retry

---------

Co-authored-by: morluto <76467478+morluto@users.noreply.github.com>
This commit is contained in:
RRFZandmorluto authored and GitHub committed 2026-11-20 00:40:51 +00:00
1 parent d405115e41
commit 0be83b62fc
3 files changed
+167 -28

No files matched your search

@@ -9,6 +9,8 @@ import {
type ProviderIdentity,
} from "../../ports/AnalysisProvider.js";
import { ProviderCleanupError } from "../../domain/providerCleanupError.js";
import { AnalysisCleanupRelease } from "../../domain/analysisCleanupRelease.js";
import { ProviderAdapterError } from "../../domain/providerAdapterError.js";
import { projectAnalysisError } from "../../domain/analysisErrorProjection.js";
import { err, ok } from "../../domain/result.js";
import { CompositeProvider } from "./CompositeProvider.js";
@@ -148,6 +150,118 @@ it("retains every failed child resource across composite cleanup retries", async
expect(right.close).toHaveBeenCalledTimes(2);
});
it.each(["live", "released", "unknown"] as const)(
"follows the second child's %s close outcome",
async (outcome) => {
const left = failingProvider("left", "address_name", "left-db");
const right = failingProvider("right", "procedure_info", "right-db");
const leftRelease = new AnalysisCleanupRelease();
const rightRelease = new AnalysisCleanupRelease();
leftRelease.bind(left.cleanupError);
if (outcome !== "unknown") rightRelease.bind(right.cleanupError);
else
right.close.mockResolvedValue(
err(new ProviderAdapterError("right", "close_binary", {})),
);
if (outcome === "released") rightRelease.confirm();
const client = new CompositeProvider([
left.provider,
right.provider,
]).createClient(executableTarget);
await client.execute("address_name", {});
await client.execute("procedure_info", {});
const closed = await client.close();
if (closed.ok) throw new Error("Expected both child closes to fail");
expect(closed.error.cleanupIncomplete).toBe(true);
leftRelease.confirm();
expect(closed.error.cleanupIncomplete).toBe(outcome !== "released");
expect(closed.error.cleanupResources).toEqual(
outcome === "live" ? ["right-db"] : [],
);
rightRelease.confirm();
expect(closed.error.cleanupIncomplete).toBe(outcome === "unknown");
left.close.mockResolvedValue(ok(null));
right.close.mockResolvedValue(ok(null));
expect(await client.close()).toEqual(ok(null));
expect(closed.error.cleanupIncomplete).toBe(false);
},
);
it("waits for each unconfirmed child to close on retry", async () => {
const left = failingProvider("left", "address_name", "left-db");
const right = failingProvider("right", "procedure_info", "right-db");
for (const child of [left, right])
child.close.mockResolvedValue(
err(
new ProviderAdapterError(child.provider.identity().id, "close_binary"),
),
);
const client = new CompositeProvider([
left.provider,
right.provider,
]).createClient(executableTarget);
await client.execute("address_name", {});
await client.execute("procedure_info", {});
const first = await client.close();
if (first.ok) throw new Error("Expected both child closes to fail");
expect(first.error.cleanupIncomplete).toBe(true);
left.close.mockResolvedValue(ok(null));
expect((await client.close()).ok).toBe(false);
expect(first.error.cleanupIncomplete).toBe(true);
right.close.mockResolvedValue(ok(null));
expect(await client.close()).toEqual(ok(null));
expect(first.error.cleanupIncomplete).toBe(false);
});
it.each(["opaque", "already released", "still owned"] as const)(
"follows selective composite retries when a child throws (%s)",
async (origin) => {
const left = failingProvider("left", "address_name", "left-db");
const right = failingProvider("right", "procedure_info", "right-db");
const leftRelease = new AnalysisCleanupRelease();
const rightRelease = new AnalysisCleanupRelease();
leftRelease.bind(left.cleanupError);
rightRelease.bind(right.cleanupError);
if (origin === "already released") rightRelease.confirm();
const physical =
origin === "opaque"
? new Error("right close rejected")
: right.cleanupError;
right.close
.mockRejectedValueOnce(physical)
.mockRejectedValueOnce(physical)
.mockResolvedValue(ok(null));
const client = new CompositeProvider([
left.provider,
right.provider,
]).createClient(executableTarget);
await client.execute("address_name", {});
await client.execute("procedure_info", {});
const initial = await client.close();
if (initial.ok || !(initial.error.cause instanceof AggregateError))
throw new Error("expected both failed children");
const stillOwned = origin === "still owned";
const [, rejected] = initial.error.cause.errors;
if (stillOwned) expect(rejected).toBe(physical);
else expect(rejected.cause).toBe(physical);
leftRelease.confirm();
left.close.mockResolvedValue(ok(null));
expect((await client.close()).ok).toBe(false);
expect(initial.error.cleanupIncomplete).toBe(true);
expect(initial.error.cleanupResources).toEqual([
stillOwned ? "right-db" : "provider-client",
]);
expect(await client.close()).toEqual(ok(null));
expect(left.close).toHaveBeenCalledTimes(2);
expect(right.close).toHaveBeenCalledTimes(3);
// Only a child's own cleanup claim can release the typed owner it reported.
expect(initial.error.cleanupIncomplete).toBe(stillOwned);
rightRelease.confirm();
expect(initial.error.cleanupIncomplete).toBe(false);
expect(initial.error.cleanupResources).toEqual([]);
},
);
it("preserves one child's typed cleanup error unchanged", async () => {
const child = failingProvider("provider-only", "address_name", "one-db");
const client = new CompositeProvider([child.provider]).createClient(
+33 -16
View File
@@ -1,5 +1,6 @@
import { AnalysisCapabilityUnavailableError } from "../../domain/analysisErrorCore.js";
import { ProviderCleanupError } from "../../domain/providerCleanupError.js";
import { AnalysisCleanupRelease } from "../../domain/analysisCleanupRelease.js";
import {
closedAnalysisClientError,
ProviderAdapterError,
@@ -32,36 +33,54 @@ const compositeProviderIdentity = (
version: null,
});
/** A retained error needs only the release records, not the clients being closed. */
const allClientsReleased = (releases: readonly AnalysisCleanupRelease[]) => ({
get cleanupReleased(): boolean {
return releases.every((release) => release.cleanupReleased);
},
});
const closeCompositeClients = (
identity: ProviderIdentity,
clients: ReadonlyMap<AnalysisProvider, AnalysisClient>,
): AnalysisClient["close"] => {
const completed = new Set<AnalysisClient>();
const releases = new WeakMap<AnalysisClient, AnalysisCleanupRelease>();
return async (options) => {
const outcomes = await Promise.all(
[...clients.entries()].map(async ([provider, client]) => {
const providerId = provider.identity().id;
if (completed.has(client)) return { providerId, result: ok(null) };
const result = await closeAnalysisClient(client, providerId, options);
if (result.ok) completed.add(client);
return { providerId, result };
let release = releases.get(client);
if (release === undefined) {
release = new AnalysisCleanupRelease();
releases.set(client, release);
}
if (release.cleanupReleased)
return { providerId, release, result: ok(null) };
const result = await closeAnalysisClient(
client,
providerId,
options,
release,
);
if (result.ok) release.confirm();
return { providerId, release, result };
}),
);
const failures = outcomes.flatMap(({ providerId, result }) =>
result.ok ? [] : [{ providerId, error: result.error }],
const failures = outcomes.flatMap(({ providerId, release, result }) =>
result.ok ? [] : [{ providerId, release, error: result.error }],
);
if (failures.length === 0) return ok(null);
if (failures.length === 1) {
const failure = failures[0];
if (failure !== undefined) return err(failure.error);
}
const resources = [
...new Set(failures.flatMap(({ error }) => error.cleanupResources)),
];
const unknownReleases = failures.flatMap(({ error, release }) =>
error.carriesCleanup ? [] : [release],
);
return err(
new ProviderCleanupError(
identity.id,
resources,
[],
{
reason:
"Multiple composed provider clients could not be confirmed closed.",
@@ -87,11 +106,9 @@ const closeCompositeClients = (
"Composed provider cleanup failed.",
),
},
).bindCleanupDependencies(
failures
.map(({ error }) => error)
.filter((error) => error.cleanupIncomplete),
),
)
.bindCleanupDependencies(failures.map(({ error }) => error))
.bindCleanupReleaseClaim(allClientsReleased(unknownReleases)),
);
};
};
+20 -12
View File
@@ -1,6 +1,9 @@
import { ProviderCleanupError } from "../domain/providerCleanupError.js";
import { err, type Result } from "../domain/result.js";
import { AnalysisError } from "../domain/analysisErrorBase.js";
import {
AnalysisError,
type AnalysisCleanupReleaseClaim,
} from "../domain/analysisErrorBase.js";
import type { AnalysisClient } from "../ports/AnalysisProvider.js";
/** Close one provider client and normalize unexpected adapter rejection. */
@@ -8,6 +11,7 @@ export const closeAnalysisClient = async (
client: AnalysisClient,
providerId: string,
options: Parameters<AnalysisClient["close"]>[0] = {},
closeRejectionRelease?: AnalysisCleanupReleaseClaim,
): Promise<Result<null, AnalysisError>> => {
// Nested/composite clients report failures before their final result settles.
// Own notification identity for this close attempt, including the fallback
@@ -27,17 +31,21 @@ export const closeAnalysisClient = async (
: { onCleanupFailure: report }),
});
} catch (cause: unknown) {
// A typed cleanup failure already names its leftover resources.
const failure =
cause instanceof AnalysisError && cause.cleanupIncomplete
? cause
: new ProviderCleanupError(
providerId,
["provider-client"],
{ reason: "provider client close rejected unexpectedly" },
{ cause },
);
result = err(failure);
if (cause instanceof AnalysisError && cause.cleanupIncomplete) {
result = err(cause);
} else {
// An unexpected rejection cannot attest this close's completion. A
// caller that retains the client can supply its own retry release.
const failure = new ProviderCleanupError(
providerId,
["provider-client"],
{ reason: "provider client close rejected unexpectedly" },
{ cause },
);
if (closeRejectionRelease !== undefined)
failure.bindCleanupReleaseClaim(closeRejectionRelease);
result = err(failure);
}
}
if (!result.ok) report(result.error);
return result;