Repository navigation
Conversation
00523e4 to
31be3f3
Compare
yuluo-yx
left a comment
There was a problem hiding this comment.
isStarted() no longer preserves started history: reproduced new task -> stop() without any start() call, yet isStarted() returns true. STARTING is also reported as started before scheduling succeeds. Preserve whether start actually succeeded and add regression coverage for stopping a never-started task.
31be3f3 to
2fc28c9
Compare
|
@yuluo-yx Fixed and pushed (2fc28c9, branch rebased onto the current main first — it picked up the merged #216 work cleanly). Root cause: my derived Fix: Regression coverage: a new test stops a never-started task and asserts |
yuluo-yx
left a comment
There was a problem hiding this comment.
The isStarted() fix looks correct, but stop-during-start still permits execution after stop returns: block schedule() before it returns a future, call stop(), then release the scheduler and invoke its supplied Runnable before returning the future. executeGraph() has no lifecycle guard, so the graph runs while STOPPED; cancelling the late future at line 152 is too late. Gate scheduled execution against stop and add a deterministic test asserting zero graph invocations for this interleaving.
…sitions (issue agentic-ai-java#215) start/stop composed their lifecycle from independent volatile started/stopped flags, so the transitions were not atomic: two concurrent starts could both pass the guard and publish two schedules, a stop racing with the schedule publication could miss the future published afterwards, a stop followed by start resurrected the stopped task, and a failed start left the registration behind. The lifecycle is now a single CAS-able state (NEW, STARTING, RUNNING, STOPPING, STOPPED, FAILED). start() claims NEW->STARTING up front, so a second start is rejected while the first is still publishing; a stop winning the STARTING window makes the late future cancelled instead of live; a scheduling failure releases the registration and lands in FAILED. stop() is idempotent through a single winner transition. The derived isStarted/isStopped keep their previous observable semantics, and all existing lifecycle/ownership tests pass unchanged. Deterministic interleaving tests gate the scheduler publication with latches: double start schedules once, start after stop is rejected, failed start unregisters, stop during start cancels the late future.
…gentic-ai-java#215 review) isStarted() derived from the lifecycle state reported started=true for a task that was only stopped (NEW -> STOPPED), and during STARTING before the schedule was published. isStarted() now reads a monotonic start-succeeded projection, set once when the STARTING -> RUNNING transition succeeds and never reset, so it answers whether a start actually succeeded while the state machine remains the single source of transitions. Regression test covers stopping a never-started task.
agentic-ai-java#215 review) stop-during-start could still let the graph run: a scheduler that executes the published task before handing out the future ran executeGraph() while the task was already STOPPED, and cancelling the late future afterwards was too late. Scheduled execution is now gated on the lifecycle state: STARTING (a one-time task may legitimately run before start() returns) and RUNNING permit execution; STOPPING, STOPPED, FAILED and NEW are skipped without lifecycle notifications. All existing lifecycle semantics, including the run-before-start-returns one-time path, are preserved. A deterministic test drives the exact interleaving - schedule blocked, stop() completes, the scheduler runs the published task before returning the future - and asserts zero graph invocations (red before: the graph ran once while stopped).
ede4af6 to
99ad2d7
Compare
|
@yuluo-yx Fixed and pushed (99ad2d7, branch rebased onto the current main first — it picked up the merged #371 work cleanly). Root cause: the lifecycle guard existed only in the state transitions, not in the execution path. Your interleaving — schedule blocked, Fix: scheduled execution is now gated on the lifecycle state inside Regression coverage: the fake scheduler now supports your exact interleaving — it runs the published task before returning the future — and the new test drives it deterministically: schedule blocked on a latch, |
|
Note on the failing |
Describe what this PR does / why we need it
Issue #215 reports that
ScheduledAgentTask.start/stopcompose their lifecycle from two independent volatile flags with no atomic transition. This PR replaces the flag pair with a single CAS-able lifecycle state and closes all four windows it exposes, with deterministic latch-driven regression tests.Root cause
Four concrete defects fall out of the flag pair. Two concurrent starts can both pass the
startedguard and each publish a schedule, leaving two live schedulings for one task. A stop racing with an in-flight start can finish before the future is published, so the late future is never cancelled and keeps triggering. A stop followed by a start succeeds:stoppedplays no role in the start guard, resurrecting a stopped task. And a start whose scheduling throws leaves the task registered forever, since the registration happens in the constructor but nothing releases it on failure.The fix
The task now holds one
AtomicReferenceover a package-privateScheduleState(NEW, STARTING, RUNNING, STOPPING, STOPPED, FAILED).start()claimsNEW → STARTINGup front, so a concurrent or repeated start is rejected while the first is still publishing the schedule. After the schedule is published,STARTING → RUNNINGmust win; ifstop()took the state during the window, the just-published future is cancelled instead of left live and the start fails. A scheduling failure moves to FAILED, releases the registration, and propagates the original exception, so a failed start strands nothing.stop()funnels through a single-winner transition to STOPPING — concurrent and repeated stops are no-ops — then cancels the future, unregisters, notifies, and lands on STOPPED. The stop semantics are unchanged:cancel(false)only, so in-flight executions are still not interrupted. No new listener events and no public API growth;isStarted/isStoppedkeep their previous observable semantics (started history is retained after stop).Testing
The new
ScheduledAgentTaskAtomicStartStopTestgates the scheduler publication with latches for deterministic interleaving: a first start blocked inside the publication window makes a concurrent second start fail with exactly one schedule published (red before: two schedules, no exception); a start after stop is rejected with no new schedule (red before: it scheduled again); a start whose scheduling throws unregisters and propagates (red before: registration left behind); a stop during the STARTING window cancels the late-published future and ends STOPPED (red before: the future stayed live and start succeeded); and the full state walk NEW → STARTING → RUNNING → STOPPING → STOPPED is asserted through a package-private observation point. The scheduling package is 19/19 green with the #214/#216 regressions untouched, checkstyle and spring-javaformat are clean. The module's 8 pre-existing failures on this baseline (skills prompt template, file store Windows path, prompt template line endings) are unrelated and unchanged.Fixes #215