mirror of
https://github.com/morluto/rea.git
synced 2026-11-20 05:32:44 +00:00
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:
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(
|
||||
|
||||
@@ -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)),
|
||||
);
|
||||
};
|
||||
};
|
||||
|
||||
@@ -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;
|
||||
|
||||
Reference in new issue
Block a user