android+server: make every view live from the pushed run events
The pipelines list (and every other run-state view) kept the row it had when the screen was last fetched. Two class-level root causes, fixed here: - The app subscribed to run events scoped to the one workspace the operator configured, so a run executing in another workspace (a lane worktree is its own workspace) never delivered a frame: the rows only changed on a manual refresh. The app now asks for the blank "any workspace" scope the server already treats as any (ALL_WORKSPACES in AppViewModel.subscribeRuns, blank default on PipelinesRepository.subscribeRuns). Workspace isolation on the server is unchanged: an explicit workspace scope still matches only that workspace (TestRunEventWorkspaceIsolation); the new TestRunEventAllWorkspacesSubscription pins the blank "any" scope. - foldRunEvent refused to insert a run the list had never held, returning needsResync and leaving the list untouched, so a run started after the screen loaded appeared only after a fetch. The pushed frame now carries the pipeline identity a row needs (RunEventFrame.PipelineID/Name/Title/Version), so the fold inserts the new run at the head from the frame's own identity without a fetch and without reordering existing rows; a server that predates those fields still falls back to the one resync. Added fields and why each is needed: pipeline_id (row's pipeline join), name (row title), title (the stored operator-facing title a row shows), version (the row's pinned version) - everything a RunSummary row renders, so no per-event fetch and no guess from stale cache. The server stamps them on every emitted frame from a per-run identity remembered at create/decide/cancel/resume (runner.go runIdentity/rememberRunIdentity/stampRunIdentity), first-write-wins through the coalescer (mergeRunEventFrame) and on the subscribe snapshot, so every transition - created/queued, running, each stage start/finish, terminal - carries them. Reconnect still resyncs once then follows pushes; the pull-to-refresh path is untouched. Checks run: go build ./..., go vet ./..., go test ./... (all packages ok), go test -race -run 'RunEvent|RunEvents|Subscribe' ./internal/protocol/ ./internal/server/, and gradle --no-daemon testDebugUnitTest assembleDebug (558 tests, 0 failures, 0 skipped; BUILD SUCCESSFUL). Packaged templates and the packaged authoring skill references were checked: nothing there describes the run_event field list or the client's subscription scope, so neither needs updating (references/notifications.md only says the attention surface is derived from the pushed run events, which is unchanged). Docs are a shared file owned by a single writer and were not edited: docs/cli.md's description of the pushed `run_event` frame still enumerates only the older fields (status, outcome, current stage, completed-step count, timestamps, optional step) and is now incomplete - it should mention the pipeline identity fields; docs/ntfy.md remains accurate.
This commit is contained in:
@@ -126,18 +126,20 @@ class PipelinesRepository(
|
||||
client.call(Message(type = Protocol.GET_RUN_EVIDENCE, runId = id)).evidence ?: emptyList()
|
||||
|
||||
/**
|
||||
* Subscribes this connection to the workspace's run-state pushes. The server
|
||||
* first sends the current state of every matching run as `run_event` frames
|
||||
* (which arrive on [events]), then a compact delta on each transition, so a
|
||||
* reconnecting client re-syncs before it applies deltas. [runIds] narrows the
|
||||
* watch; an empty list watches the whole workspace.
|
||||
* Subscribes this connection to run-state pushes. The server first sends the
|
||||
* current state of every matching run as `run_event` frames (which arrive on
|
||||
* [events]), then a compact delta on each transition, so a reconnecting client
|
||||
* re-syncs before it applies deltas. [workspace] scopes the watch; the default
|
||||
* blank scope watches every workspace, which is what the runs list displays
|
||||
* (the work an operator watches can run in any workspace). [runIds] narrows
|
||||
* the watch further; an empty list watches the whole scope.
|
||||
*
|
||||
* Returns the request id and does not wait for the ack: a server that never
|
||||
* acks must not block the send lock, and the pushes themselves confirm the
|
||||
* watch (see `AppViewModel.observeRunEvents`). Any ack or error reply lands on
|
||||
* [events] with this id.
|
||||
*/
|
||||
suspend fun subscribeRuns(workspace: String, runIds: List<Long> = emptyList()): String =
|
||||
suspend fun subscribeRuns(workspace: String = "", runIds: List<Long> = emptyList()): String =
|
||||
client.sendOnly(
|
||||
Message(
|
||||
type = Protocol.SUBSCRIBE,
|
||||
|
||||
@@ -399,6 +399,14 @@ data class RunDetail(
|
||||
data class RunEventFrame(
|
||||
@SerialName("run_id") val runId: Long = 0,
|
||||
val workspace: String = "",
|
||||
// The run's pipeline identity and stored title, repeated on every frame so a
|
||||
// client that has never held the run can build its list row from the frame
|
||||
// (the fold's new-run case) rather than re-reading the whole list. Blank on a
|
||||
// server that predates them, which makes the fold fall back to a resync.
|
||||
@SerialName("pipeline_id") val pipelineId: Long = 0,
|
||||
val name: String = "",
|
||||
val title: String = "",
|
||||
val version: Int = 0,
|
||||
val status: String = "",
|
||||
val outcome: String = "",
|
||||
@SerialName("current_stage") val currentStage: String = "",
|
||||
|
||||
@@ -166,12 +166,13 @@ class AppViewModel(
|
||||
.distinctUntilChanged()
|
||||
.stateIn(viewModelScope, SharingStarted.Eagerly, chatStore.value.active != null)
|
||||
|
||||
// The live run subscription: the workspace currently watched, the job that
|
||||
// established it, and the coalescing jobs that re-sync on a push. One
|
||||
// subscription per connection; a reconnect (which clears this watch, not the
|
||||
// saved workspace) re-subscribes, and every (re)subscribe re-reads the list so
|
||||
// the gap re-syncs from the server's current state. No timer is involved:
|
||||
// every refresh here is driven by a push, a (re)connect or an operator action.
|
||||
// The live run subscription: the scope currently watched (always
|
||||
// [ALL_WORKSPACES] while subscribed, null when not), the job that established
|
||||
// it, and the coalescing jobs that re-sync on a push. One subscription per
|
||||
// connection; a reconnect (which clears this watch, not the saved workspace)
|
||||
// re-subscribes, and every (re)subscribe re-reads the list so the gap re-syncs
|
||||
// from the server's current state. No timer is involved: every refresh here is
|
||||
// driven by a push, a (re)connect or an operator action.
|
||||
private var subscribedWorkspace: String? = null
|
||||
private var subscriptionJob: Job? = null
|
||||
// The id of the last subscribe we sent, so its optional ack or error reply
|
||||
@@ -250,19 +251,22 @@ class AppViewModel(
|
||||
connected = isConnected
|
||||
}
|
||||
}
|
||||
// The run stream is live only while connected to the right workspace: the
|
||||
// pair (connected, workspace) drives a single subscribe. A reconnect drops
|
||||
// the socket, so the pair emits (false, workspace) — which clears the watch
|
||||
// — then (true, workspace), which re-subscribes; a subscribe re-reads the
|
||||
// list first so the gap is re-synced before any later delta applies.
|
||||
// The run stream watches every workspace the client displays. The runs
|
||||
// list — and so the pipelines list's last-run line and every run summary
|
||||
// card — is server-wide (list_runs is not workspace-scoped), while the
|
||||
// work an operator watches can run in any workspace (a lane worktree is
|
||||
// its own workspace). A watch scoped to the one configured workspace
|
||||
// never receives those runs, which is exactly the stale row this fixes,
|
||||
// so the client asks for the blank "any workspace" scope the server
|
||||
// already honours. A reconnect drops the socket, so this emits false
|
||||
// (which clears the watch) then true, which re-subscribes; a subscribe
|
||||
// re-reads the list first so the gap is re-synced before any later delta
|
||||
// applies.
|
||||
viewModelScope.launch {
|
||||
combine(connectionState, settings.workspace) { state, workspace ->
|
||||
(state is ConnectionState.Connected) to workspace
|
||||
}
|
||||
connectionState
|
||||
.map { it is ConnectionState.Connected }
|
||||
.distinctUntilChanged()
|
||||
.collect { (live, workspace) ->
|
||||
if (live && workspace.isNotBlank()) subscribeRuns(workspace) else streamDown()
|
||||
}
|
||||
.collect { live -> if (live) subscribeRuns() else streamDown() }
|
||||
}
|
||||
}
|
||||
|
||||
@@ -339,19 +343,22 @@ class AppViewModel(
|
||||
}
|
||||
|
||||
/**
|
||||
* Establishes the one watch over [workspace]. A workspace switch drops the
|
||||
* previous watch first (the server caps subscriptions per connection), and
|
||||
* the watch is confirmed live by its ack, its first push or the read that
|
||||
* follows (see [observeRunEvents]) rather than assumed: if the server cannot
|
||||
* subscribe, the stream reads as not live instead of silently stale.
|
||||
* Establishes the one watch over every workspace the client displays (the
|
||||
* blank scope, which the server treats as "any"): the runs list is
|
||||
* server-wide, so the client asks for the runs it shows rather than the one
|
||||
* workspace the operator configured. A reconnect (which clears this watch)
|
||||
* re-subscribes, and the watch is confirmed live by its ack, its first push
|
||||
* or the read that follows (see [observeRunEvents]) rather than assumed: if
|
||||
* the server cannot subscribe, the stream reads as not live instead of
|
||||
* silently stale.
|
||||
*/
|
||||
private fun subscribeRuns(workspace: String) {
|
||||
if (subscribedWorkspace == workspace) return
|
||||
private fun subscribeRuns() {
|
||||
if (subscribedWorkspace == ALL_WORKSPACES) return
|
||||
subscriptionJob?.cancel()
|
||||
_runStream.value = RunStreamState.Connecting
|
||||
subscriptionJob = viewModelScope.launch {
|
||||
try {
|
||||
// Drop any previous watch so a workspace switch never stacks
|
||||
// Drop any previous watch so a reconnect never stacks
|
||||
// subscriptions (the server caps them per connection). A failed
|
||||
// drop must not stop the new subscribe, but it is not swallowed:
|
||||
// the badge stays not-live until a push confirms the new watch.
|
||||
@@ -363,8 +370,8 @@ class AppViewModel(
|
||||
}
|
||||
// Mark the watch before sending so a push that races the send is
|
||||
// still attributed to this subscription.
|
||||
subscribedWorkspace = workspace
|
||||
subscriptionId = repository.subscribeRuns(workspace)
|
||||
subscribedWorkspace = ALL_WORKSPACES
|
||||
subscriptionId = repository.subscribeRuns()
|
||||
// The server's subscribe snapshot is not guaranteed complete (the
|
||||
// running server's can be partial), so take an authoritative read
|
||||
// of the watched state once per (re)connect; later pushes then fold
|
||||
@@ -1107,6 +1114,15 @@ class AppViewModel(
|
||||
companion object {
|
||||
private const val CONNECT_TIMEOUT_MILLIS = 20_000L
|
||||
|
||||
/**
|
||||
* The run watch scope for every workspace the client displays. The server
|
||||
* treats a blank subscribe workspace as "any", matching the server-wide
|
||||
* runs list rather than the one workspace the operator configured: work
|
||||
* the operator watches can run in any workspace (a lane worktree is its
|
||||
* own), so a workspace-scoped watch would never see it.
|
||||
*/
|
||||
private const val ALL_WORKSPACES = ""
|
||||
|
||||
/** Bounded backoff retries for a push-driven list/detail read that failed. */
|
||||
private const val RESYNC_RETRY_LIMIT = 3
|
||||
private const val RESYNC_RETRY_BASE_MILLIS = 500L
|
||||
|
||||
@@ -13,10 +13,12 @@ import net.awan.pipelines.data.protocol.RunSummary
|
||||
* count) is advanced here from the pushes.
|
||||
*
|
||||
* The fold is deliberately monotonic so an out-of-order or duplicated delta can
|
||||
* never move a run or a step backwards, and a delta that names a run the list
|
||||
* does not hold reports [RunListFold.needsResync] rather than inventing a row:
|
||||
* a brand-new run's summary (name, pipeline id, version) is not in the compact
|
||||
* delta, so the caller re-reads the server's current list once instead.
|
||||
* never move a run or a step backwards. A delta that names a run the list does
|
||||
* not hold is inserted as a new row from the frame's own identity (pipeline id,
|
||||
* name, title, version), so a run started after the screen loaded appears
|
||||
* without a fetch; only a frame with no such identity (an older server) reports
|
||||
* [RunListFold.needsResync], and the caller re-reads the server's current list
|
||||
* once instead.
|
||||
*/
|
||||
|
||||
/** Run statuses from which a run never transitions again. */
|
||||
@@ -62,15 +64,26 @@ internal fun stepLifecycleRank(status: String): Int = when (status.trim().lowerc
|
||||
/**
|
||||
* The outcome of folding one frame into the runs list: the list with the matching
|
||||
* run updated in place (same order, so a read never reshuffles), or
|
||||
* [needsResync] when the frame names a run the list does not hold.
|
||||
* [needsResync] when the frame names a run the list does not hold and carries no
|
||||
* identity to build its row from.
|
||||
*/
|
||||
internal data class RunListFold(val runs: List<RunSummary>, val needsResync: Boolean)
|
||||
|
||||
/** Folds one pushed frame into the runs list, in place and without reordering. */
|
||||
/**
|
||||
* Folds one pushed frame into the runs list, in place and without reordering.
|
||||
* A run the list has never held is inserted as a new row at the head (newest
|
||||
* first, matching the server's own order) when the frame carries its pipeline
|
||||
* identity, so a run started after the screen loaded appears while the operator
|
||||
* watches without a fetch; a frame with no identity (an older server) still
|
||||
* reports [RunListFold.needsResync] so the caller re-reads once instead.
|
||||
*/
|
||||
internal fun foldRunEvent(runs: List<RunSummary>, frame: RunEventFrame): RunListFold {
|
||||
if (frame.runId <= 0) return RunListFold(runs, needsResync = false)
|
||||
val index = runs.indexOfFirst { it.id == frame.runId }
|
||||
if (index < 0) return RunListFold(runs, needsResync = true)
|
||||
if (index < 0) {
|
||||
val added = frame.newRunSummary() ?: return RunListFold(runs, needsResync = true)
|
||||
return RunListFold(listOf(added) + runs, needsResync = false)
|
||||
}
|
||||
val current = runs[index]
|
||||
val updated = current.applying(frame)
|
||||
if (updated == current) return RunListFold(runs, needsResync = false)
|
||||
@@ -79,6 +92,30 @@ internal fun foldRunEvent(runs: List<RunSummary>, frame: RunEventFrame): RunList
|
||||
return RunListFold(next, needsResync = false)
|
||||
}
|
||||
|
||||
/**
|
||||
* The row a frame for a run the list has never held describes, or null when the
|
||||
* frame lacks the pipeline identity a row needs (an older server), in which case
|
||||
* the caller resyncs instead of inventing an incomplete row. The frame already
|
||||
* carries everything the row shows, so no field is guessed from cached state.
|
||||
*/
|
||||
internal fun RunEventFrame.newRunSummary(): RunSummary? {
|
||||
if (pipelineId <= 0 || name.isBlank()) return null
|
||||
return RunSummary(
|
||||
id = runId,
|
||||
pipelineId = pipelineId,
|
||||
name = name,
|
||||
title = title.ifBlank { null },
|
||||
version = version,
|
||||
status = status,
|
||||
executing = executingFor(status, true),
|
||||
outcome = outcome,
|
||||
currentStage = currentStage,
|
||||
createdAt = createdAt,
|
||||
finishedAt = finishedAt,
|
||||
completedSteps = completedSteps,
|
||||
)
|
||||
}
|
||||
|
||||
/**
|
||||
* Folds one pushed frame into a cached run detail: the run's own status/outcome/
|
||||
* stage/timestamps plus at most one step, matched by sequence so a duplicate or
|
||||
|
||||
@@ -75,13 +75,23 @@ class RunEventsTest {
|
||||
completedSteps: Int = 0,
|
||||
finishedAt: String = "",
|
||||
step: RunStepDelta? = null,
|
||||
pipelineId: Long = 0,
|
||||
name: String = "",
|
||||
title: String = "",
|
||||
version: Int = 0,
|
||||
createdAt: String = "",
|
||||
) = RunEventFrame(
|
||||
runId = runId,
|
||||
workspace = "/work",
|
||||
pipelineId = pipelineId,
|
||||
name = name,
|
||||
title = title,
|
||||
version = version,
|
||||
status = status,
|
||||
outcome = outcome,
|
||||
currentStage = currentStage,
|
||||
completedSteps = completedSteps,
|
||||
createdAt = createdAt,
|
||||
finishedAt = finishedAt,
|
||||
step = step,
|
||||
)
|
||||
@@ -107,15 +117,68 @@ class RunEventsTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
fun aCreatedRunNotInTheListAsksForAResyncInsteadOfInventingARow() {
|
||||
fun aNewRunAppearsFromItsFrameWithoutAFetch() {
|
||||
val runs = listOf(summary(1, status = "succeeded", executing = false))
|
||||
// The server tags the frame with the pipeline identity a row needs, so a
|
||||
// run started after the screen loaded is inserted rather than resynced.
|
||||
val fold = foldRunEvent(
|
||||
runs,
|
||||
frame(
|
||||
runId = 9,
|
||||
status = "queued",
|
||||
pipelineId = 4,
|
||||
name = "pipeline",
|
||||
title = "a fresh run",
|
||||
version = 3,
|
||||
createdAt = "2026-10-17T09:30:00Z",
|
||||
),
|
||||
)
|
||||
assertFalse(fold.needsResync)
|
||||
// The existing rows keep their relative order; the new run is added first
|
||||
// (the server's own newest-first order), never spliced between them.
|
||||
assertEquals(listOf(9L, 1L), fold.runs.map { it.id })
|
||||
val added = fold.runs.first()
|
||||
assertEquals(4L, added.pipelineId)
|
||||
assertEquals("pipeline", added.name)
|
||||
assertEquals("a fresh run", added.title)
|
||||
assertEquals(3, added.version)
|
||||
assertEquals("queued", added.status)
|
||||
assertTrue(added.executing)
|
||||
assertEquals("2026-10-17T09:30:00Z", added.createdAt)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun aFrameForAnUnknownRunWithoutIdentityStillAsksForAResync() {
|
||||
val runs = listOf(summary(1))
|
||||
// A brand-new run's compact delta carries no name/pipeline/version, so the
|
||||
// list cannot render it and must re-read the server's current state.
|
||||
// A server that predates the identity fields carries none: the list cannot
|
||||
// render the row and must re-read the server's current state once.
|
||||
val fold = foldRunEvent(runs, frame(runId = 9, status = "queued"))
|
||||
assertTrue(fold.needsResync)
|
||||
assertSame(runs, fold.runs)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun anInsertedRunThenAdvancesInPlace() {
|
||||
// A run inserted from its created frame must later update in place, so a
|
||||
// live run shows running and then succeeded without being re-inserted.
|
||||
val created = foldRunEvent(
|
||||
emptyList(),
|
||||
frame(runId = 9, status = "queued", pipelineId = 4, name = "pipeline", version = 1, createdAt = "2026-10-17T09:30:00Z"),
|
||||
).runs
|
||||
val running = foldRunEvent(created, frame(runId = 9, status = "running", currentStage = "build", completedSteps = 1))
|
||||
assertFalse(running.needsResync)
|
||||
assertEquals(1, running.runs.size)
|
||||
assertEquals("running", running.runs[0].status)
|
||||
assertEquals("build", running.runs[0].currentStage)
|
||||
val done = foldRunEvent(
|
||||
running.runs,
|
||||
frame(runId = 9, status = "succeeded", outcome = "success", completedSteps = 1, finishedAt = "2026-10-17T09:31:00Z"),
|
||||
)
|
||||
assertEquals(1, done.runs.size)
|
||||
assertEquals("succeeded", done.runs[0].status)
|
||||
assertFalse(done.runs[0].executing)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun aDeltaForAnUnknownRunAlsoAsksForAResync() {
|
||||
val runs = listOf(summary(1, status = "succeeded", executing = false))
|
||||
|
||||
@@ -1,8 +1,10 @@
|
||||
package net.awan.pipelines.ui.screens
|
||||
|
||||
import java.time.OffsetDateTime
|
||||
import net.awan.pipelines.data.protocol.RunEventFrame
|
||||
import net.awan.pipelines.data.protocol.RunSummary
|
||||
import net.awan.pipelines.ui.components.RunState
|
||||
import net.awan.pipelines.ui.foldRunEvent
|
||||
import org.junit.Assert.assertEquals
|
||||
import org.junit.Assert.assertNull
|
||||
import org.junit.Assert.assertTrue
|
||||
@@ -142,4 +144,63 @@ class PipelineLastRunTest {
|
||||
fun noRunsWordingIsTheExplicitConstant() {
|
||||
assertEquals("no runs recorded", NO_RUNS_RECORDED)
|
||||
}
|
||||
|
||||
private fun eventFrame(
|
||||
runId: Long,
|
||||
status: String,
|
||||
createdAt: String = "",
|
||||
finishedAt: String = "",
|
||||
pipelineId: Long = 0,
|
||||
name: String = "",
|
||||
version: Int = 0,
|
||||
) = RunEventFrame(
|
||||
runId = runId,
|
||||
pipelineId = pipelineId,
|
||||
name = name,
|
||||
version = version,
|
||||
status = status,
|
||||
createdAt = createdAt,
|
||||
finishedAt = finishedAt,
|
||||
)
|
||||
|
||||
@Test
|
||||
fun thePipelinesLastRunLineFollowsARunFromRunningToSucceeded() {
|
||||
val runs = listOf(
|
||||
run(42, 10, "2026-10-16T11:57:30Z", finishedAt = "", status = "running", executing = true),
|
||||
)
|
||||
// A pushed terminal frame settles the run in the folded list; the pipeline
|
||||
// row's badge — the same join the pipelines list renders — follows without
|
||||
// a refresh.
|
||||
val folded = foldRunEvent(
|
||||
runs,
|
||||
eventFrame(runId = 42, status = "succeeded", finishedAt = "2026-10-16T11:59:30Z"),
|
||||
).runs
|
||||
val badge = pipelineRunBadges(folded, now).getValue(10L)
|
||||
assertEquals(RunState.Succeeded, badge.state)
|
||||
assertEquals(42L, badge.runId)
|
||||
assertEquals("2m ago · 2m 0s · run 42", badge.metaLine())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun aNewRunAppearsOnThePipelinesLastRunLineFromItsFrame() {
|
||||
// The pipeline's only recorded run had already finished...
|
||||
val runs = listOf(run(41, 10, "2026-10-16T10:00:00Z", finishedAt = "2026-10-16T10:01:00Z"))
|
||||
// ...and a run started after the screen loaded arrives only as a push. It
|
||||
// must become the pipeline's last-run line with no fetch.
|
||||
val folded = foldRunEvent(
|
||||
runs,
|
||||
eventFrame(
|
||||
runId = 42,
|
||||
status = "running",
|
||||
createdAt = "2026-10-16T11:58:00Z",
|
||||
pipelineId = 10,
|
||||
name = "release",
|
||||
version = 2,
|
||||
),
|
||||
).runs
|
||||
val badge = pipelineRunBadges(folded, now).getValue(10L)
|
||||
assertEquals(42L, badge.runId)
|
||||
assertEquals(RunState.Running, badge.state)
|
||||
assertEquals("2m ago · 2m 0s · run 42", badge.metaLine())
|
||||
}
|
||||
}
|
||||
|
||||
@@ -18,9 +18,20 @@ const (
|
||||
// stage, completed-step count and timestamps, plus at most one changed step.
|
||||
// Every field is optional so an older peer ignores what it does not know and a
|
||||
// client can fold the frame into its cached run.
|
||||
//
|
||||
// PipelineID, Name, Title and Version are the pipeline identity and stored title
|
||||
// a list row shows, so a client that has never held the run can insert its row
|
||||
// from the frame instead of re-reading the whole list. They repeat on every
|
||||
// frame (pipeline identity never changes mid-run).
|
||||
type RunEventFrame struct {
|
||||
RunID int64 `json:"run_id"`
|
||||
Workspace string `json:"workspace,omitempty"`
|
||||
RunID int64 `json:"run_id"`
|
||||
Workspace string `json:"workspace,omitempty"`
|
||||
// PipelineID, Name, Title and Version identify the run's pipeline and its
|
||||
// operator-facing title, so a new run's row can be built without a fetch.
|
||||
PipelineID int64 `json:"pipeline_id,omitempty"`
|
||||
Name string `json:"name,omitempty"`
|
||||
Title string `json:"title,omitempty"`
|
||||
Version int `json:"version,omitempty"`
|
||||
Status string `json:"status,omitempty"`
|
||||
Outcome string `json:"outcome,omitempty"`
|
||||
CurrentStage string `json:"current_stage,omitempty"`
|
||||
|
||||
@@ -8,10 +8,12 @@ import (
|
||||
)
|
||||
|
||||
// TestRunEventGoldenJSON pins the exact wire shape of the pushed run_event frame
|
||||
// so a JSON tag change cannot silently alter what a client parses.
|
||||
// so a JSON tag change cannot silently alter what a client parses. The pipeline
|
||||
// identity fields let a client build a brand-new run's row from the frame.
|
||||
func TestRunEventGoldenJSON(t *testing.T) {
|
||||
frame := RunEventFrame{
|
||||
RunID: 7, Workspace: "/work", Status: RunStatusRunning, CurrentStage: "build",
|
||||
RunID: 7, Workspace: "/work", PipelineID: 4, Name: "release", Title: "Ship it", Version: 3,
|
||||
Status: RunStatusRunning, CurrentStage: "build",
|
||||
CompletedSteps: 1, CreatedAt: "2026-01-02T03:04:05Z", Artifacts: 2,
|
||||
Step: &RunStepDelta{Sequence: 2, Stage: "build", Status: "completed", Outcome: "success", Target: SuccessEnd, Artifacts: 2},
|
||||
}
|
||||
@@ -19,7 +21,7 @@ func TestRunEventGoldenJSON(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
want := `{"run_id":7,"workspace":"/work","status":"running","current_stage":"build","completed_steps":1,"created_at":"2026-01-02T03:04:05Z","artifacts":2,"step":{"sequence":2,"stage":"build","status":"completed","outcome":"success","target":"#success","artifacts":2}}`
|
||||
want := `{"run_id":7,"workspace":"/work","pipeline_id":4,"name":"release","title":"Ship it","version":3,"status":"running","current_stage":"build","completed_steps":1,"created_at":"2026-01-02T03:04:05Z","artifacts":2,"step":{"sequence":2,"stage":"build","status":"completed","outcome":"success","target":"#success","artifacts":2}}`
|
||||
if string(encoded) != want {
|
||||
t.Fatalf("golden mismatch\n got %s\nwant %s", encoded, want)
|
||||
}
|
||||
@@ -32,6 +34,21 @@ func TestRunEventGoldenJSON(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
// TestRunEventOmitsBlankIdentity proves a frame without identity (a run with no
|
||||
// remembered identity) omits the fields entirely, so an older peer sees exactly
|
||||
// the previous shape and a client falls back to its resync.
|
||||
func TestRunEventOmitsBlankIdentity(t *testing.T) {
|
||||
encoded, err := json.Marshal(RunEventFrame{RunID: 3, Workspace: "/w", Status: RunStatusQueued})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, absent := range []string{"pipeline_id", "name", "title", "version"} {
|
||||
if strings.Contains(string(encoded), absent) {
|
||||
t.Fatalf("blank %q must be omitted: %s", absent, encoded)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TestRunEventEnvelopeRoundTrip proves the new optional fields survive the shared
|
||||
// Message envelope and that an unused payload is omitted from the wire.
|
||||
func TestRunEventEnvelopeRoundTrip(t *testing.T) {
|
||||
|
||||
@@ -161,6 +161,13 @@ func TestRunEventWebSocketPushesTransitions(t *testing.T) {
|
||||
if stepStarted == nil || stepStarted.RunID != runID || stepStarted.Status != protocol.RunStatusRunning || stepStarted.CurrentStage != "one" || stepStarted.Step.Sequence != 1 || stepStarted.Step.Stage != "one" {
|
||||
t.Fatalf("step-started frame = %+v", stepStarted)
|
||||
}
|
||||
// Every frame carries the run's pipeline identity and stored title, so a
|
||||
// client that has never held the run can build its list row from the frame.
|
||||
for name, frame := range map[string]*protocol.RunEventFrame{"created": created, "step-started": stepStarted} {
|
||||
if frame.PipelineID != ids[0] || frame.Name == "" || frame.Title == "" || frame.Version != 1 {
|
||||
t.Fatalf("%s frame identity = %+v, want pipeline %d with name/title and version 1", name, frame, ids[0])
|
||||
}
|
||||
}
|
||||
if stepFinished == nil || stepFinished.RunID != runID || stepFinished.Step.Status != "completed" || stepFinished.Step.Outcome != "success" || stepFinished.Step.Target != protocol.SuccessEnd || stepFinished.CompletedSteps != 1 {
|
||||
t.Fatalf("step-finished frame = %+v", stepFinished)
|
||||
}
|
||||
@@ -195,11 +202,27 @@ func TestRunEventSubscribeSendsSnapshot(t *testing.T) {
|
||||
if first.RunEvent.RunID != run.ID || first.RunEvent.Status != "succeeded" || first.RunEvent.CompletedSteps != 1 || first.RunEvent.FinishedAt == "" {
|
||||
t.Fatalf("snapshot frame = %+v", first.RunEvent)
|
||||
}
|
||||
// A snapshot for a run the client never saw also carries the identity its row
|
||||
// needs, so a fresh subscribe renders it without a second read.
|
||||
if first.RunEvent.PipelineID != ids[0] || first.RunEvent.Name == "" || first.RunEvent.Version != 1 {
|
||||
t.Fatalf("snapshot identity = %+v, want pipeline %d version 1", first.RunEvent, ids[0])
|
||||
}
|
||||
if ack := client.read(); ack.Type != protocol.Subscribe || ack.ID != "snap" {
|
||||
t.Fatalf("subscribe ack = %+v", ack)
|
||||
}
|
||||
}
|
||||
|
||||
// TestMergeRunEventFrameKeepsIdentity proves a coalesced frame keeps the run's
|
||||
// identity from an earlier transition when a later delta omits it, so the merged
|
||||
// frame a client actually receives still carries what its row needs.
|
||||
func TestMergeRunEventFrameKeepsIdentity(t *testing.T) {
|
||||
into := &protocol.RunEventFrame{RunID: 1, PipelineID: 4, Name: "release", Title: "Ship it", Version: 3, Status: protocol.RunStatusQueued}
|
||||
mergeRunEventFrame(into, &protocol.RunEventFrame{RunID: 1, Status: protocol.RunStatusRunning, CurrentStage: "build"})
|
||||
if into.PipelineID != 4 || into.Name != "release" || into.Title != "Ship it" || into.Version != 3 || into.Status != protocol.RunStatusRunning {
|
||||
t.Fatalf("merged identity lost: %+v", into)
|
||||
}
|
||||
}
|
||||
|
||||
// assertNoRunEvent reads for d, ignoring responses, and fails if any run_event
|
||||
// frame arrives.
|
||||
func assertNoRunEvent(t *testing.T, client *runEventClient, d time.Duration) {
|
||||
@@ -288,6 +311,49 @@ func TestRunEventWorkspaceIsolation(t *testing.T) {
|
||||
assertNoRunEvent(t, client, 400*time.Millisecond)
|
||||
}
|
||||
|
||||
// TestRunEventAllWorkspacesSubscription proves the blank ("any workspace")
|
||||
// subscribe scope — the one the app now asks for because its runs list is
|
||||
// server-wide — delivers a run from every workspace, while an explicit
|
||||
// workspace scope stays isolated (TestRunEventWorkspaceIsolation). It is what
|
||||
// lets the app see a run executing in a lane worktree, a different workspace
|
||||
// from the one the operator configured.
|
||||
func TestRunEventAllWorkspacesSubscription(t *testing.T) {
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
|
||||
defer cancel()
|
||||
_, handler, ids := eventStore(t, ctx, "one")
|
||||
handler.runner.execute = func(context.Context, stage.Definition, stage.Values) (stage.Result, error) {
|
||||
return stage.Result{Outcome: "success", Output: stage.Values{}}, nil
|
||||
}
|
||||
first := eventWorkspace(t)
|
||||
second := eventWorkspace(t)
|
||||
client := dialRunEvents(t, ctx, handler)
|
||||
// The blank workspace is the "every workspace" scope; no run_ids narrows it.
|
||||
client.send(protocol.Message{Type: protocol.Subscribe, ID: "all", Workspace: ""})
|
||||
if ack := client.read(); ack.Type != protocol.Subscribe || ack.ID != "all" {
|
||||
t.Fatalf("subscribe ack = %+v", ack)
|
||||
}
|
||||
// Subscribe first, then start a run in each workspace, so both are delivered
|
||||
// as live deltas rather than only in the snapshot.
|
||||
client.send(protocol.Message{Type: protocol.RunPipeline, ID: "a", PipelineID: ids[0], Version: 1, RequestKey: "all-ws-a", Workspace: first, Input: map[string]any{"prompt": "test"}})
|
||||
client.send(protocol.Message{Type: protocol.RunPipeline, ID: "b", PipelineID: ids[0], Version: 1, RequestKey: "all-ws-b", Workspace: second, Input: map[string]any{"prompt": "test"}})
|
||||
|
||||
terminals := map[string]*protocol.RunEventFrame{}
|
||||
deadline := time.Now().Add(8 * time.Second)
|
||||
for len(terminals) < 2 && time.Now().Before(deadline) {
|
||||
message := client.read()
|
||||
if message.Type != protocol.RunEvent || message.RunEvent == nil {
|
||||
continue
|
||||
}
|
||||
frame := message.RunEvent
|
||||
if frame.Status == "succeeded" || frame.Status == "failed" || frame.Status == "canceled" {
|
||||
terminals[frame.Workspace] = frame
|
||||
}
|
||||
}
|
||||
if terminals[first] == nil || terminals[second] == nil {
|
||||
t.Fatalf("blank-scope subscription missed a workspace: got %v", terminals)
|
||||
}
|
||||
}
|
||||
|
||||
// TestRunEventCoalescingBoundsFrameCount records how many run_event frames a
|
||||
// typical multi-stage run produces and asserts the count stays bounded: rapid
|
||||
// transitions coalesce, and the terminal frame is never dropped.
|
||||
|
||||
@@ -353,6 +353,20 @@ func mergeRunEventFrame(into, in *protocol.RunEventFrame) {
|
||||
if in.Workspace != "" {
|
||||
into.Workspace = in.Workspace
|
||||
}
|
||||
// Identity is fixed for a run's life, so the first frame that carries it wins
|
||||
// and a later delta never blanks it.
|
||||
if into.PipelineID == 0 {
|
||||
into.PipelineID = in.PipelineID
|
||||
}
|
||||
if into.Name == "" {
|
||||
into.Name = in.Name
|
||||
}
|
||||
if into.Title == "" {
|
||||
into.Title = in.Title
|
||||
}
|
||||
if into.Version == 0 {
|
||||
into.Version = in.Version
|
||||
}
|
||||
if in.Status != "" {
|
||||
into.Status = in.Status
|
||||
}
|
||||
@@ -410,6 +424,10 @@ func handleRunEvents(request protocol.Message, events *runEventHub, runs *runner
|
||||
sub.send(protocol.RunEventFrame{
|
||||
RunID: summary.ID,
|
||||
Workspace: summary.Workspace,
|
||||
PipelineID: summary.PipelineID,
|
||||
Name: summary.Name,
|
||||
Title: summary.Title,
|
||||
Version: summary.Version,
|
||||
Status: summary.Status,
|
||||
Outcome: summary.Outcome,
|
||||
CurrentStage: summary.CurrentStage,
|
||||
|
||||
@@ -47,6 +47,13 @@ type runner struct {
|
||||
// events pushes run state deltas to subscribed clients. When nil (tests that
|
||||
// build a runner directly) emits are dropped, so nothing else changes.
|
||||
events *runEventHub
|
||||
// identMu guards idents: the pipeline identity and stored title (see
|
||||
// runIdentity) that every emitted frame of a run carries, so a client with no
|
||||
// cached row renders a brand-new run without re-reading the list. Populated
|
||||
// where a run is created, decided or canceled; a run with no remembered
|
||||
// identity keeps blank identity fields and the client resyncs once instead.
|
||||
identMu sync.Mutex
|
||||
idents map[int64]runIdentity
|
||||
// exportSession writes a finished stage's session into its own artifacts
|
||||
// directory. It defaults to stage.ExportSession; a failure is best-effort and
|
||||
// never changes the stage's status, outcome, target or result validation.
|
||||
@@ -82,7 +89,7 @@ func newRunner(ctx context.Context, s *pipeline.Store) (*runner, error) {
|
||||
return nil, err
|
||||
}
|
||||
root := filepath.Join(s.Directory(), "artifacts")
|
||||
return &runner{ctx: ctx, store: s, artifactsRoot: root, active: map[int64]activeRun{}, attentionSent: map[int64]map[string]bool{}, exportSession: stage.ExportSession}, nil
|
||||
return &runner{ctx: ctx, store: s, artifactsRoot: root, active: map[int64]activeRun{}, idents: map[int64]runIdentity{}, attentionSent: map[int64]map[string]bool{}, exportSession: stage.ExportSession}, nil
|
||||
}
|
||||
|
||||
func (r *runner) start(request protocol.Message, retryOf ...int64) (*protocol.RunDetail, error) {
|
||||
@@ -252,6 +259,18 @@ func (r *runner) start(request protocol.Message, retryOf ...int64) (*protocol.Ru
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
// The run row now exists: read it once for its resolved identity (pipeline
|
||||
// id/name, the store-derived title, the pinned version), so the queued frame
|
||||
// and every later frame carry what a client needs to render a brand-new run
|
||||
// without re-reading the list. A failed read only costs that seed: the run is
|
||||
// still launched below and its frames carry no identity, so the client falls
|
||||
// back to its one resync.
|
||||
detail, readErr := r.store.GetRun(r.ctx, id)
|
||||
if readErr != nil {
|
||||
detail = nil
|
||||
} else if detail != nil {
|
||||
r.rememberRunIdentity(id, identityOfRunSummary(detail.RunSummary))
|
||||
}
|
||||
if created {
|
||||
// Emit the created delta before launching: the queued frame reaches
|
||||
// subscribers before the running/step-started transition, so a client
|
||||
@@ -266,12 +285,14 @@ func (r *runner) start(request protocol.Message, retryOf ...int64) (*protocol.Ru
|
||||
r.run(ctx, id, d, workspace, request)
|
||||
})
|
||||
}
|
||||
detail, err := r.store.GetRun(r.ctx, id)
|
||||
if detail != nil {
|
||||
_, detail.Executing = r.active[id]
|
||||
r.overlayEffectiveModels(detail)
|
||||
}
|
||||
return detail, err
|
||||
if readErr != nil {
|
||||
return nil, readErr
|
||||
}
|
||||
return detail, nil
|
||||
}
|
||||
|
||||
// launch registers an active run's cancellation seam and workspace, adds it to
|
||||
@@ -406,6 +427,7 @@ func (r *runner) cancel(id int64) error {
|
||||
r.forgetAttention(id)
|
||||
if r.events != nil {
|
||||
if detail, err := r.store.GetRun(r.ctx, id); err == nil && detail != nil {
|
||||
r.rememberRunIdentity(id, identityOfRunSummary(detail.RunSummary))
|
||||
r.emitRun(protocol.RunEventFrame{
|
||||
RunID: id,
|
||||
Workspace: detail.Workspace,
|
||||
@@ -450,6 +472,9 @@ func (r *runner) decide(request protocol.Message) (*protocol.RunDetail, error) {
|
||||
return nil, err
|
||||
}
|
||||
if applied {
|
||||
// Re-seed the identity so the resumed frames (this one and the resumed
|
||||
// loop's) carry it even after a restart, when no creation was observed.
|
||||
r.rememberRunIdentity(detail.ID, identityOfRunSummary(detail.RunSummary))
|
||||
for i := range detail.Steps {
|
||||
if detail.Steps[i].Sequence == step.Sequence && detail.Steps[i].Stage == step.Stage {
|
||||
detail.Steps[i] = step
|
||||
@@ -518,6 +543,9 @@ func terminalFinish(target, stageKey, outcome, diagnostic string) (status, final
|
||||
// shared loop from the decision's target; no full-table scan and no extra
|
||||
// per-step query are introduced.
|
||||
func (r *runner) resume(ctx context.Context, id int64, d *protocol.RunDetail, workspace string, step protocol.RunStep) {
|
||||
// A resumed run's frames carry the same identity as its creation, so re-seed
|
||||
// it here too: resume is also reachable from a store read after a restart.
|
||||
r.rememberRunIdentity(id, identityOfRunSummary(d.RunSummary))
|
||||
// The decision may route straight to a terminal, which has no stage to run.
|
||||
if status, outcome, diagnostic, terminal := terminalFinish(step.Target, step.Stage, step.Outcome, step.Diagnostic); terminal {
|
||||
r.finishRunState(id, d.Name, workspace, status, outcome, diagnostic, completedSteps(d.Steps), step.Sequence, step.Stage, stage.Values(step.Output))
|
||||
@@ -615,6 +643,60 @@ func (s *runState) publishServerChangedFiles() {
|
||||
s.memory["input"] = entry
|
||||
}
|
||||
|
||||
// runIdentity is the pipeline identity and stored title a run's pushed frames
|
||||
// carry (RunEventFrame.PipelineID/Name/Title/Version). It is remembered where a
|
||||
// run is created, decided or canceled and stamped onto every frame that leaves
|
||||
// emitRun, so a client that has never seen the run can build its list row from
|
||||
// the frame without re-reading the whole list.
|
||||
type runIdentity struct {
|
||||
pipelineID int64
|
||||
name string
|
||||
title string
|
||||
version int
|
||||
}
|
||||
|
||||
// identityOfRunSummary is the one projection of a run row onto the identity its
|
||||
// pushed frames carry, so the frame and the list row cannot disagree.
|
||||
func identityOfRunSummary(s protocol.RunSummary) runIdentity {
|
||||
return runIdentity{pipelineID: s.PipelineID, name: s.Name, title: s.Title, version: s.Version}
|
||||
}
|
||||
|
||||
// rememberRunIdentity records the identity every later frame of run id carries.
|
||||
// It is safe from any goroutine and takes its own lock (never r.mu), so it is
|
||||
// callable from a path that already holds r.mu.
|
||||
func (r *runner) rememberRunIdentity(id int64, ident runIdentity) {
|
||||
if r.idents == nil {
|
||||
return
|
||||
}
|
||||
r.identMu.Lock()
|
||||
r.idents[id] = ident
|
||||
r.identMu.Unlock()
|
||||
}
|
||||
|
||||
// stampRunIdentity fills a frame's blank identity fields from the run's
|
||||
// remembered identity, leaving any the emit site set untouched. A run with no
|
||||
// remembered identity keeps them blank, so the client falls back to its resync.
|
||||
func (r *runner) stampRunIdentity(frame *protocol.RunEventFrame) {
|
||||
r.identMu.Lock()
|
||||
ident, ok := r.idents[frame.RunID]
|
||||
r.identMu.Unlock()
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
if frame.PipelineID == 0 {
|
||||
frame.PipelineID = ident.pipelineID
|
||||
}
|
||||
if frame.Name == "" {
|
||||
frame.Name = ident.name
|
||||
}
|
||||
if frame.Title == "" {
|
||||
frame.Title = ident.title
|
||||
}
|
||||
if frame.Version == 0 {
|
||||
frame.Version = ident.version
|
||||
}
|
||||
}
|
||||
|
||||
// emitRun pushes one run delta to the subscribed-client hub when one is wired,
|
||||
// and does nothing otherwise (a runner built directly in a test has no hub).
|
||||
// terminal marks a final transition, which the hub flushes without coalescing.
|
||||
@@ -622,6 +704,7 @@ func (r *runner) emitRun(frame protocol.RunEventFrame, terminal bool) {
|
||||
if r.events == nil {
|
||||
return
|
||||
}
|
||||
r.stampRunIdentity(&frame)
|
||||
r.events.emit(frame, terminal)
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user