Skip to content

Free, Open Source, Self-Hosted WhatsApp API Gateway

fix(session): renew the lease of a session being deleted

Yudhi Armyndharis719e48f0f0cb
diff --git a/src/modules/session/session-delete-race.spec.ts b/src/modules/session/session-delete-race.spec.ts
index d53534051..180125b73 100644
--- a/src/modules/session/session-delete-race.spec.ts
+++ b/src/modules/session/session-delete-race.spec.ts
@@ -70,6 +70,7 @@ describe('A session being deleted', () => {
let db: DataSource;
let module: TestingModule;
let service: SessionService;
+ let lifecycle: SessionEngineLifecycle;
let ownership: SessionOwnershipService;
let engineFactory: { create: jest.Mock; purgeSessionData: jest.Mock };
let sessionId: string;
@@ -77,6 +78,9 @@ describe('A session being deleted', () => {
let finishBatch: ReturnType<typeof deferred>;
let deletion: Promise<void>;
+ const config = (nodeId: string): ConfigService =>
+ new ConfigService({ session: { nodeId, leaseTtlMs: 60_000, leaseHeartbeatMs: 20_000 } });
+
beforeEach(async () => {
db = new DataSource({ type: 'better-sqlite3', database: ':memory:', entities, synchronize: true });
await db.initialize();
@@ -125,7 +129,10 @@ describe('A session being deleted', () => {
],
}).compile();
service = module.get(SessionService);
+ lifecycle = module.get(SessionEngineLifecycle);
ownership = module.get(SessionOwnershipService);
+ // What SessionService wires at bootstrap, without the interval: renew() asks whether anything still runs.
+ ownership.setEngineLiveness(id => lifecycle.isEngineActive(id));
const row = await db.getRepository(Session).save({
name: 'big-session',
@@ -180,4 +187,16 @@ describe('A session being deleted', () => {
// The stop of a session that no longer exists answers 404, which it could not if an engine lingered.
await expect(service.stop(sessionId)).rejects.toThrow('not found');
});
+
+ it('keeps its lease with the node that is deleting it, so a peer cannot adopt it meanwhile', async () => {
+ // Stands in for batches that outlast the lease TTL: without a renewal the peer takes the row.
+ await db.getRepository(Session).update(sessionId, { leaseExpiresAt: new Date(Date.now() - 1_000) });
+ const peer = new SessionOwnershipService(db.getRepository(Session), config('node-b'));
+
+ await ownership.renew();
+
+ expect(await peer.claim(sessionId)).toBe(false);
+ finishBatch.resolve();
+ await deletion;
+ });
});
diff --git a/src/modules/session/session-engine-lifecycle-races.spec.ts b/src/modules/session/session-engine-lifecycle-races.spec.ts
index e9bc83d72..c2d58387e 100644
--- a/src/modules/session/session-engine-lifecycle-races.spec.ts
+++ b/src/modules/session/session-engine-lifecycle-races.spec.ts
@@ -292,6 +292,18 @@ describe('SessionEngineLifecycle races', () => {
expect(internals.stoppingSessions.has(ID)).toBe(false);
});
+ it('counts the delete as live until the rows are gone, so the lease of the session is renewed', async () => {
+ expect(lifecycle.isEngineActive(ID)).toBe(false);
+ const { gate, settled } = await deleteInBatchPhase();
+
+ // The engine is evicted and nothing is starting or reconnecting: only the delete is left.
+ expect(lifecycle.isEngineActive(ID)).toBe(true);
+
+ gate.resolve([]);
+ await settled;
+ expect(lifecycle.isEngineActive(ID)).toBe(false);
+ });
+
it('lets the session start again when the delete failed', async () => {
transaction.mockRejectedValueOnce(new Error('canceling statement due to statement timeout'));
const { gate, settled } = await deleteInBatchPhase();
diff --git a/src/modules/session/session-engine-lifecycle.service.ts b/src/modules/session/session-engine-lifecycle.service.ts
index 0997e6423..a74460d84 100644
--- a/src/modules/session/session-engine-lifecycle.service.ts
+++ b/src/modules/session/session-engine-lifecycle.service.ts
@@ -556,13 +556,15 @@ export class SessionEngineLifecycle {
/**
* True while this process still has anything alive for the session: a registered engine, an
- * in-flight start(), or reconnect state whose armed/executing attempt will re-register one.
+ * in-flight start(), reconnect state whose armed/executing attempt will re-register one, or a
+ * delete still removing its rows (its engine is gone by then, but a peer that adopted the lapsed
+ * lease would start the session being deleted).
* The ownership heartbeat consults this so a claim that no longer covers an engine stops being
* renewed and can lapse for a peer to adopt; the service-level release paths consult it so an
* "already starting/started" refusal never releases a session this node genuinely runs.
*/
isEngineActive(id: string): boolean {
- if (this.engines.has(id) || this.initializingSessions.has(id)) return true;
+ if (this.engines.has(id) || this.initializingSessions.has(id) || this.controls.isDeleting(id)) return true;
// Reconnect state counts only while an attempt is actually pending: a timer armed by
// scheduleReconnect, or one that has fired and is running executeReconnect (which has already
// counted its attempt). The entry start() creates up