@@ -16,6 +16,7 @@ import { acquireDeviceClaim } from '@agent-device/daemon-contracts/device-claims
1616import { existingSessionExecutionLockKeys } from '../request-binding.ts' ;
1717import { withRequestExecutionLockKeys } from '../request-execution-locks.ts' ;
1818import type { SessionStore } from '../../core/session-store.ts' ;
19+ import type { PlatformResourceCleanup } from '../../core/platform-resource-cleanup.ts' ;
1920import type { SessionTeardown } from '../../sessions/lease-lifecycle.ts' ;
2021import { createLeaseSessionEnd } from '../request-execution-scope.ts' ;
2122
@@ -67,7 +68,13 @@ function holdSessionLocks(
6768 return { finish, held } ;
6869}
6970
70- function leaseSessionEnd ( sessionStore : SessionStore , teardownSession : SessionTeardown ) {
71+ function leaseSessionEnd (
72+ sessionStore : SessionStore ,
73+ teardownSession : SessionTeardown ,
74+ cleanupSessionlessExecutionHost : PlatformResourceCleanup [ 'cleanupSessionlessExecutionHost' ] = vi . fn (
75+ async ( ) => { } ,
76+ ) ,
77+ ) {
7178 const executionLocks = new Map < string , Promise < unknown > > ( ) ;
7279 return {
7380 executionLocks,
@@ -76,12 +83,259 @@ function leaseSessionEnd(sessionStore: SessionStore, teardownSession: SessionTea
7683 sessionStore,
7784 executionLocks,
7885 teardownSession,
86+ cleanupSessionlessExecutionHost,
7987 } ) ,
8088 } ;
8189}
8290
8391const settle = async ( ) : Promise < void > => await new Promise ( ( resolve ) => setImmediate ( resolve ) ) ;
8492
93+ function retainExecutionHost ( sessionStore : SessionStore , name = 'leased' , leaseId = 'lease-1' ) {
94+ const ref = sessionStore . publish (
95+ name ,
96+ makeIosSession ( name , {
97+ lease : { leaseId, tenantId : 'tenant-a' , runId : 'run-1' } ,
98+ } ) ,
99+ ) ;
100+ sessionStore . retire ( ref , { retainExecutionHost : true } ) ;
101+ return ref ;
102+ }
103+
104+ test . each ( [ 'LEASE_RELEASED' , 'LEASE_EXPIRED' ] as const ) (
105+ '%s stops a retained host after its session has retired' ,
106+ async ( reason ) => {
107+ const sessionStore = makeSessionStore ( ) ;
108+ const ref = retainExecutionHost ( sessionStore ) ;
109+ const cleanup = vi . fn ( async ( ) => { } ) ;
110+ const teardown = vi . fn ( async ( ) => { } ) ;
111+ const { ender } = leaseSessionEnd ( sessionStore , teardown , cleanup ) ;
112+
113+ await ender . end ( 'lease-1' , reason ) ;
114+
115+ expect ( teardown ) . not . toHaveBeenCalled ( ) ;
116+ expect ( cleanup ) . toHaveBeenCalledExactlyOnceWith ( ref . session . device ) ;
117+ expect ( sessionStore . listRetainedExecutionHosts ( 'lease-1' ) ) . toEqual ( [ ] ) ;
118+ } ,
119+ ) ;
120+
121+ test ( 'expiry waiting behind close cleans the host that close retains before retiring' , async ( ) => {
122+ const sessionStore = makeSessionStore ( ) ;
123+ const ref = sessionStore . publish (
124+ 'leased' ,
125+ makeIosSession ( 'leased' , {
126+ lease : { leaseId : 'lease-1' , tenantId : 'tenant-a' , runId : 'run-1' } ,
127+ } ) ,
128+ ) ;
129+ const cleanup = vi . fn ( async ( ) => { } ) ;
130+ const teardown = vi . fn ( async ( ) => { } ) ;
131+ const { executionLocks, ender } = leaseSessionEnd ( sessionStore , teardown , cleanup ) ;
132+ const close = holdSessionLocks ( executionLocks , sessionStore , 'leased' ) ;
133+ const ending = ender . end ( 'lease-1' , 'LEASE_EXPIRED' ) ;
134+ await settle ( ) ;
135+ expect ( cleanup ) . not . toHaveBeenCalled ( ) ;
136+
137+ sessionStore . retire ( ref , { retainExecutionHost : true } ) ;
138+ close . finish ( ) ;
139+ await close . held ;
140+ await ending ;
141+
142+ expect ( teardown ) . not . toHaveBeenCalled ( ) ;
143+ expect ( cleanup ) . toHaveBeenCalledExactlyOnceWith ( ref . session . device ) ;
144+ expect ( sessionStore . listRetainedExecutionHosts ( 'lease-1' ) ) . toEqual ( [ ] ) ;
145+ } ) ;
146+
147+ test . each ( [ false , true ] ) (
148+ 'lease end preserves a replacement owner with retained=%s' ,
149+ async ( retained ) => {
150+ const sessionStore = makeSessionStore ( ) ;
151+ const old = retainExecutionHost ( sessionStore ) ;
152+ const cleanup = vi . fn ( async ( ) => { } ) ;
153+ const { executionLocks, ender } = leaseSessionEnd ( sessionStore , async ( ) => { } , cleanup ) ;
154+ let unlock ! : ( ) => void ;
155+ const held = withRequestExecutionLockKeys (
156+ executionLocks ,
157+ existingSessionExecutionLockKeys ( old . address , old . session . device . id ) ,
158+ async ( ) =>
159+ await new Promise < void > ( ( resolve ) => {
160+ unlock = resolve ;
161+ } ) ,
162+ ) ;
163+ await settle ( ) ;
164+ const ending = ender . end ( 'lease-1' , 'LEASE_RELEASED' ) ;
165+ await settle ( ) ;
166+ const replacement = sessionStore . publish (
167+ 'replacement' ,
168+ makeIosSession ( 'replacement' , {
169+ lease : { leaseId : 'lease-2' , tenantId : 'tenant-b' , runId : 'run-2' } ,
170+ } ) ,
171+ ) ;
172+ if ( retained ) sessionStore . retire ( replacement , { retainExecutionHost : true } ) ;
173+ unlock ( ) ;
174+ await held ;
175+ await ending ;
176+
177+ expect ( cleanup ) . not . toHaveBeenCalled ( ) ;
178+ expect ( sessionStore . listRetainedExecutionHosts ( 'lease-1' ) ) . toEqual ( [ ] ) ;
179+ if ( retained ) expect ( sessionStore . listRetainedExecutionHosts ( 'lease-2' ) ) . toHaveLength ( 1 ) ;
180+ else expect ( sessionStore . resolveCurrent ( replacement ) ) . toBeDefined ( ) ;
181+ } ,
182+ ) ;
183+
184+ test ( 'release ends a same-lease reopen published at a new address while cleanup waits for its device' , async ( ) => {
185+ const sessionStore = makeSessionStore ( ) ;
186+ const old = retainExecutionHost ( sessionStore ) ;
187+ const cleanup = vi . fn ( async ( ) => { } ) ;
188+ const teardown = vi . fn ( async ( ) => { } ) ;
189+ const { executionLocks, ender } = leaseSessionEnd ( sessionStore , teardown , cleanup ) ;
190+ let finishNativeOpen ! : ( ) => void ;
191+ const nativeOpen = new Promise < void > ( ( resolve ) => {
192+ finishNativeOpen = resolve ;
193+ } ) ;
194+ const reopening = withRequestExecutionLockKeys (
195+ executionLocks ,
196+ existingSessionExecutionLockKeys ( 'reopened' , old . session . device . id ) ,
197+ async ( ) => {
198+ await nativeOpen ;
199+ sessionStore . publish ( 'reopened' , makeIosSession ( 'reopened' , { lease : old . session . lease } ) ) ;
200+ } ,
201+ ) ;
202+ await settle ( ) ;
203+ const ending = ender . end ( 'lease-1' , 'LEASE_RELEASED' ) ;
204+ await settle ( ) ;
205+ expect ( teardown ) . not . toHaveBeenCalled ( ) ;
206+ finishNativeOpen ( ) ;
207+ await reopening ;
208+ await ending ;
209+
210+ expect ( cleanup ) . not . toHaveBeenCalled ( ) ;
211+ expect ( teardown ) . toHaveBeenCalledExactlyOnceWith (
212+ expect . objectContaining ( { address : 'reopened' } ) ,
213+ ) ;
214+ expect ( sessionStore . get ( 'reopened' ) ) . toBeUndefined ( ) ;
215+ expect ( sessionStore . listRetainedExecutionHosts ( 'lease-1' ) ) . toEqual ( [ ] ) ;
216+ } ) ;
217+
218+ test ( 'failed retained-host cleanup stays owned and throttles retries without another release request' , async ( ) => {
219+ const now = vi . spyOn ( Date , 'now' ) . mockReturnValue ( 0 ) ;
220+ try {
221+ const sessionStore = makeSessionStore ( ) ;
222+ retainExecutionHost ( sessionStore ) ;
223+ const cleanup = vi
224+ . fn ( async ( ) => { } )
225+ . mockRejectedValueOnce ( new Error ( 'device unreachable' ) )
226+ . mockRejectedValueOnce ( new Error ( 'device still unreachable' ) ) ;
227+ const { ender } = leaseSessionEnd ( sessionStore , async ( ) => { } , cleanup ) ;
228+
229+ await ender . end ( 'lease-1' , 'LEASE_RELEASED' ) ;
230+ expect ( sessionStore . listRetainedExecutionHosts ( 'lease-1' ) ) . toHaveLength ( 1 ) ;
231+ for ( let elapsed = 1_000 ; elapsed < 10_000 ; elapsed += 1_000 ) {
232+ now . mockReturnValue ( elapsed ) ;
233+ await ender . retryPending ( ) ;
234+ expect ( cleanup ) . toHaveBeenCalledTimes ( 1 ) ;
235+ }
236+ now . mockReturnValue ( 10_000 ) ;
237+ await ender . retryPending ( ) ;
238+ expect ( cleanup ) . toHaveBeenCalledTimes ( 2 ) ;
239+ expect ( sessionStore . listRetainedExecutionHosts ( 'lease-1' ) ) . toHaveLength ( 1 ) ;
240+ now . mockReturnValue ( 19_999 ) ;
241+ await ender . retryPending ( ) ;
242+ expect ( cleanup ) . toHaveBeenCalledTimes ( 2 ) ;
243+ now . mockReturnValue ( 20_000 ) ;
244+ await ender . retryPending ( ) ;
245+ expect ( cleanup ) . toHaveBeenCalledTimes ( 3 ) ;
246+ expect ( sessionStore . listRetainedExecutionHosts ( 'lease-1' ) ) . toEqual ( [ ] ) ;
247+ now . mockReturnValue ( 30_000 ) ;
248+ await ender . retryPending ( ) ;
249+ expect ( cleanup ) . toHaveBeenCalledTimes ( 3 ) ;
250+ } finally {
251+ now . mockRestore ( ) ;
252+ }
253+ } ) ;
254+
255+ test ( 'cancel preserves a retained host queued for cleanup for daemon shutdown' , async ( ) => {
256+ const sessionStore = makeSessionStore ( ) ;
257+ const ref = retainExecutionHost ( sessionStore ) ;
258+ const cleanup = vi . fn ( async ( ) => { } ) ;
259+ const { executionLocks, ender } = leaseSessionEnd ( sessionStore , async ( ) => { } , cleanup ) ;
260+ let unlock ! : ( ) => void ;
261+ const held = withRequestExecutionLockKeys (
262+ executionLocks ,
263+ existingSessionExecutionLockKeys ( ref . address , ref . session . device . id ) ,
264+ async ( ) =>
265+ await new Promise < void > ( ( resolve ) => {
266+ unlock = resolve ;
267+ } ) ,
268+ ) ;
269+ await settle ( ) ;
270+ const ending = ender . end ( 'lease-1' , 'LEASE_EXPIRED' ) ;
271+ await settle ( ) ;
272+ ender . cancel ( ) ;
273+ unlock ( ) ;
274+ await held ;
275+ await ending ;
276+ await ender . drain ( ) ;
277+ await ender . retryPending ( ) ;
278+
279+ expect ( cleanup ) . not . toHaveBeenCalled ( ) ;
280+ expect ( sessionStore . listRetainedExecutionHosts ( 'lease-1' ) ) . toHaveLength ( 1 ) ;
281+ } ) ;
282+
283+ test ( 'retry does not queue duplicate cleanup and shutdown drains a running retained-host stop' , async ( ) => {
284+ const sessionStore = makeSessionStore ( ) ;
285+ retainExecutionHost ( sessionStore ) ;
286+ let finish ! : ( ) => void ;
287+ const cleanup = vi . fn (
288+ async ( ) =>
289+ await new Promise < void > ( ( resolve ) => {
290+ finish = resolve ;
291+ } ) ,
292+ ) ;
293+ const { ender } = leaseSessionEnd ( sessionStore , async ( ) => { } , cleanup ) ;
294+ const ending = ender . end ( 'lease-1' , 'LEASE_EXPIRED' ) ;
295+ await settle ( ) ;
296+ await ender . retryPending ( ) ;
297+ expect ( cleanup ) . toHaveBeenCalledTimes ( 1 ) ;
298+ ender . cancel ( ) ;
299+ let drained = false ;
300+ const drain = ender . drain ( ) . then ( ( ) => {
301+ drained = true ;
302+ } ) ;
303+ await settle ( ) ;
304+ expect ( drained ) . toBe ( false ) ;
305+ finish ( ) ;
306+ await ending ;
307+ await drain ;
308+ expect ( sessionStore . listRetainedExecutionHosts ( 'lease-1' ) ) . toEqual ( [ ] ) ;
309+ } ) ;
310+
311+ test ( 'a request holding the device lock can end its lease ahead of a queued background end' , async ( ) => {
312+ const sessionStore = makeSessionStore ( ) ;
313+ const ref = retainExecutionHost ( sessionStore ) ;
314+ const cleanup = vi . fn ( async ( ) => { } ) ;
315+ const { executionLocks, ender } = leaseSessionEnd ( sessionStore , async ( ) => { } , cleanup ) ;
316+ let release ! : ( ) => void ;
317+ const continueRequest = new Promise < void > ( ( resolve ) => {
318+ release = resolve ;
319+ } ) ;
320+ const request = withRequestExecutionLockKeys (
321+ executionLocks ,
322+ existingSessionExecutionLockKeys ( ref . address , ref . session . device . id ) ,
323+ async ( ) => {
324+ await continueRequest ;
325+ await ender . end ( 'lease-1' , 'LEASE_RELEASED' ) ;
326+ } ,
327+ ) ;
328+ await settle ( ) ;
329+ const expiry = ender . end ( 'lease-1' , 'LEASE_EXPIRED' ) ;
330+ await settle ( ) ;
331+ release ( ) ;
332+ await request ;
333+ await expiry ;
334+
335+ expect ( cleanup ) . toHaveBeenCalledTimes ( 1 ) ;
336+ expect ( sessionStore . listRetainedExecutionHosts ( 'lease-1' ) ) . toEqual ( [ ] ) ;
337+ } ) ;
338+
85339test ( 'end publishes the recorded script of the session it ends' , async ( ) => {
86340 const sessionStore = makeSessionStore ( 'agent-device-lease-end-script-' ) ;
87341 await publishLeasedSession ( sessionStore , 'leased' , 'lease-1' ) ;
0 commit comments