From 0be83b62fc0de83531ce40a30c28996827786d33 Mon Sep 17 00:00:00 2001 From: RRFZ <247457381+Plastic-time@users.noreply.github.com> Date: Thu, 19 Nov 2026 19:40:51 -0500 Subject: [PATCH] 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> --- .../binary/CompositeProvider.test.ts | 114 ++++++++++++++++++ src/application/binary/CompositeProvider.ts | 49 +++++--- src/providers/AnalysisClientCleanup.ts | 32 +++-- 3 files changed, 167 insertions(+), 28 deletions(-) diff --git a/src/application/binary/CompositeProvider.test.ts b/src/application/binary/CompositeProvider.test.ts index 74be4e2bb3..3c0b53e566 100644 --- a/src/application/binary/CompositeProvider.test.ts +++ b/src/application/binary/CompositeProvider.test.ts @@ -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( diff --git a/src/application/binary/CompositeProvider.ts b/src/application/binary/CompositeProvider.ts index c1d28c0ffe..9dc7857218 100644 --- a/src/application/binary/CompositeProvider.ts +++ b/src/application/binary/CompositeProvider.ts @@ -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, ): AnalysisClient["close"] => { - const completed = new Set(); + const releases = new WeakMap(); 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)), ); }; }; diff --git a/src/providers/AnalysisClientCleanup.ts b/src/providers/AnalysisClientCleanup.ts index 34bfcbea79..ffa64548e0 100644 --- a/src/providers/AnalysisClientCleanup.ts +++ b/src/providers/AnalysisClientCleanup.ts @@ -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[0] = {}, + closeRejectionRelease?: AnalysisCleanupReleaseClaim, ): Promise> => { // 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;