feat(dashboard): show jobq node tree in build queue
Add NodeView::parent to the wire (hive-sh4re + hive-c0re dag_view), then render the recursive parent/child tree in the dashboard build queue instead of the previous flat chain/fan-out layout. Wire change (hive-sh4re, hive-c0re): - NodeView gains parent: Option<NodeId> (skip_serializing_if = None) - dag_view() projects node.parent, filtering out the Dag container id (top-level work nodes become parent: None on the wire) Frontend (builds.js): - Replace nodeComponents + splitFanOut with buildNodeTree (uses parent edges directly) + topoSort helper (orders siblings by deps) - renderTreeNode walks the tree depth-first, rendering indented rows with └─/├─ connectors and agent label per chip - Flat chains and fan-out heuristics are gone; structure comes straight from the scheduler's parent axis Closes: none (parent issue tracked in forge)
This commit is contained in:
iris
mara
parent
309adec07f
commit
cb936fe2fe
3 changed files with 94 additions and 142 deletions
|
|
@ -157,134 +157,61 @@ function firstFailedNode(entry) {
|
|||
return (entry.nodes || []).find((n) => n.state === 'failed') || null;
|
||||
}
|
||||
|
||||
// Further split one weakly-connected component's topo-ordered nodes on
|
||||
// *fan-out* points — a node with more than one direct dependent — so a
|
||||
// shared gate/lock node (e.g. MetaLock, which every agent's rebuild
|
||||
// subgraph now hangs off via AfterOk since the meta-update cascade was
|
||||
// folded into one in-DAG growth instead of separate per-agent child DAGs)
|
||||
// doesn't merge N otherwise-independent per-agent chains into one
|
||||
// wall-of-chips line. Pure
|
||||
// `deps`-structure-driven, same as the WCC split above — no `agent` field
|
||||
// involved. Rule: a node with out-degree > 1 renders as its own one-node
|
||||
// line; each of its direct dependents becomes the root of an independent
|
||||
// line, walked forward until the next fan-out point or a dead end. A
|
||||
// component with no fan-out (the common single-agent case) comes back
|
||||
// unchanged as one line.
|
||||
function splitFanOut(orderedNodes) {
|
||||
const ids = new Set(orderedNodes.map((n) => n.id));
|
||||
const children = new Map(orderedNodes.map((n) => [n.id, []])); // dep -> direct dependents
|
||||
for (const n of orderedNodes) {
|
||||
for (const d of n.deps || []) {
|
||||
if (children.has(d)) children.get(d).push(n.id);
|
||||
}
|
||||
}
|
||||
const byId = new Map(orderedNodes.map((n) => [n.id, n]));
|
||||
const indeg = new Map(orderedNodes.map((n) => [n.id, 0]));
|
||||
for (const n of orderedNodes) {
|
||||
// Topo-sort a flat node list using `deps` edges. Nodes whose deps are all
|
||||
// absent (Done, filtered) or within the set come first. Falls back to
|
||||
// original array order on ties or cycles.
|
||||
function topoSort(nodes) {
|
||||
const ids = new Set(nodes.map((n) => n.id));
|
||||
const indeg = new Map(nodes.map((n) => [n.id, 0]));
|
||||
for (const n of nodes) {
|
||||
for (const d of n.deps || []) {
|
||||
if (ids.has(d)) indeg.set(n.id, indeg.get(n.id) + 1);
|
||||
}
|
||||
}
|
||||
const roots = orderedNodes.filter((n) => indeg.get(n.id) === 0).map((n) => n.id);
|
||||
|
||||
const lines = [];
|
||||
const visited = new Set();
|
||||
function walk(startId, chain) {
|
||||
let cur = startId;
|
||||
while (cur != null && !visited.has(cur)) {
|
||||
visited.add(cur);
|
||||
const kids = children.get(cur) || [];
|
||||
if (kids.length > 1) {
|
||||
if (chain.length) lines.push(chain);
|
||||
lines.push([byId.get(cur)]);
|
||||
for (const k of kids) walk(k, []);
|
||||
return;
|
||||
const remaining = new Map(nodes.map((n) => [n.id, n]));
|
||||
const ordered = [];
|
||||
const ready = nodes.filter((n) => indeg.get(n.id) === 0);
|
||||
while (ready.length) {
|
||||
const n = ready.shift();
|
||||
if (!remaining.has(n.id)) continue;
|
||||
remaining.delete(n.id);
|
||||
ordered.push(n);
|
||||
for (const other of nodes) {
|
||||
if ((other.deps || []).includes(n.id) && remaining.has(other.id)) {
|
||||
indeg.set(other.id, indeg.get(other.id) - 1);
|
||||
if (indeg.get(other.id) === 0) ready.push(other);
|
||||
}
|
||||
chain.push(byId.get(cur));
|
||||
cur = kids.length === 1 ? kids[0] : null;
|
||||
}
|
||||
if (chain.length) lines.push(chain);
|
||||
}
|
||||
for (const r of roots) walk(r, []);
|
||||
// Any leftover (shouldn't happen for a DAG reachable from its roots, but
|
||||
// guard against a dep loop / disconnected leftover rather than dropping
|
||||
// nodes from the display).
|
||||
for (const n of orderedNodes) {
|
||||
if (!visited.has(n.id)) lines.push([n]);
|
||||
for (const n of nodes) {
|
||||
if (remaining.has(n.id)) ordered.push(n);
|
||||
}
|
||||
return lines.length ? lines : [orderedNodes];
|
||||
return ordered;
|
||||
}
|
||||
|
||||
// Split a DAG's nodes into its actual weakly-connected subgraphs, using the
|
||||
// `deps` edges the backend provides — not an inferred heuristic like
|
||||
// grouping by `n.agent`. A DAG with independent subgraphs (e.g. a
|
||||
// multi-agent restart, no cross-agent deps) naturally splits into one
|
||||
// component per subgraph; a single connected DAG stays one component. Each
|
||||
// component's nodes come back topo-sorted (Kahn's algorithm, falling back to
|
||||
// original array order for ties) so a chain renders in actual dependency
|
||||
// order rather than raw array order. Each component is then further split
|
||||
// on fan-out points (see `splitFanOut`) so a shared gate node doesn't merge
|
||||
// independent branches into one line.
|
||||
function nodeComponents(nodes) {
|
||||
if (!nodes.length) return [];
|
||||
const byId = new Map(nodes.map((n) => [n.id, n]));
|
||||
const adj = new Map(nodes.map((n) => [n.id, new Set()])); // undirected, for component split
|
||||
for (const n of nodes) {
|
||||
for (const d of n.deps || []) {
|
||||
if (!byId.has(d)) continue; // dep outside this node set (shouldn't happen)
|
||||
adj.get(n.id).add(d);
|
||||
adj.get(d).add(n.id);
|
||||
// Build a tree from a flat node list using the `parent` field provided by
|
||||
// the backend. Nodes without a `parent` (or whose parent id is absent from
|
||||
// the node set) are roots. Children within each parent group are
|
||||
// topo-sorted by `deps` so siblings render in dependency order.
|
||||
// Returns an array of root nodes, each augmented with a `_children` array.
|
||||
function buildNodeTree(nodes) {
|
||||
const byId = new Map(nodes.map((n) => [n.id, { ...n, _children: [] }]));
|
||||
const roots = [];
|
||||
for (const n of byId.values()) {
|
||||
const p = n.parent != null ? byId.get(n.parent) : null;
|
||||
if (p) {
|
||||
p._children.push(n);
|
||||
} else {
|
||||
roots.push(n);
|
||||
}
|
||||
}
|
||||
const seen = new Set();
|
||||
const components = [];
|
||||
for (const n of nodes) {
|
||||
if (seen.has(n.id)) continue;
|
||||
const compIds = [];
|
||||
const stack = [n.id];
|
||||
seen.add(n.id);
|
||||
while (stack.length) {
|
||||
const id = stack.pop();
|
||||
compIds.push(id);
|
||||
for (const nb of adj.get(id)) {
|
||||
if (!seen.has(nb)) {
|
||||
seen.add(nb);
|
||||
stack.push(nb);
|
||||
}
|
||||
}
|
||||
}
|
||||
const compSet = new Set(compIds);
|
||||
const compNodes = nodes.filter((cn) => compSet.has(cn.id));
|
||||
// Topo-sort within the component via its actual `deps` edges (directed).
|
||||
const indeg = new Map(compNodes.map((cn) => [cn.id, 0]));
|
||||
for (const cn of compNodes) {
|
||||
for (const d of cn.deps || []) {
|
||||
if (compSet.has(d)) indeg.set(cn.id, indeg.get(cn.id) + 1);
|
||||
}
|
||||
}
|
||||
const ordered = [];
|
||||
const ready = compNodes.filter((cn) => indeg.get(cn.id) === 0);
|
||||
const remaining = new Map(compNodes.map((cn) => [cn.id, cn]));
|
||||
while (ready.length) {
|
||||
const cn = ready.shift();
|
||||
if (!remaining.has(cn.id)) continue;
|
||||
remaining.delete(cn.id);
|
||||
ordered.push(cn);
|
||||
for (const other of compNodes) {
|
||||
if ((other.deps || []).includes(cn.id) && remaining.has(other.id)) {
|
||||
indeg.set(other.id, indeg.get(other.id) - 1);
|
||||
if (indeg.get(other.id) === 0) ready.push(other);
|
||||
}
|
||||
}
|
||||
}
|
||||
// Any leftover (cycle, or a dep outside the node set) — append in
|
||||
// original order rather than dropping nodes from the display.
|
||||
for (const cn of compNodes) {
|
||||
if (remaining.has(cn.id)) ordered.push(cn);
|
||||
}
|
||||
for (const line of splitFanOut(ordered)) components.push(line);
|
||||
// Topo-sort roots and each children list by deps.
|
||||
function sortGroup(group) {
|
||||
const sorted = topoSort(group);
|
||||
for (const n of sorted) sortGroup(n._children);
|
||||
return sorted;
|
||||
}
|
||||
return components;
|
||||
return sortGroup(roots);
|
||||
}
|
||||
|
||||
function rebuildQueueEntryFingerprint(entry) {
|
||||
|
|
@ -390,38 +317,47 @@ function renderQueueEntry(entry) {
|
|||
const r = entry.reason.split('\n')[0];
|
||||
li.append(' ', el('span', { class: 'rqe-reason', title: entry.reason }, '— ' + truncate(r, 60)));
|
||||
}
|
||||
// Per-node chain: every DAG node in dependency order with its own state
|
||||
// glyph and a log link. The DAG's actual shape is its `deps` graph —
|
||||
// render that structure (via nodeComponents) not a heuristic grouping.
|
||||
// Per-node tree: render the jobq recursive parent/child tree.
|
||||
// `parent` edges (structural grouping) define the tree shape;
|
||||
// `deps` edges order siblings within each parent group.
|
||||
// `Done` nodes are excluded from the payload by the backend, so only
|
||||
// live nodes appear here; `Failed` DAGs linger until the history cap.
|
||||
if (nodes.length) {
|
||||
const components = nodeComponents(nodes);
|
||||
for (const compNodes of components) {
|
||||
const chain = el('div', { class: 'rqe-nodes' });
|
||||
compNodes.forEach((n, i) => {
|
||||
if (i > 0) chain.append(el('span', { class: 'rqe-node-arrow' }, ' → '));
|
||||
const chip = el('span', {
|
||||
class: 'rqe-node rqe-node-' + n.state,
|
||||
title: n.kind + ' · ' + n.state + (n.error ? ' — ' + n.error : ''),
|
||||
},
|
||||
(QUEUE_STATE_GLYPH[n.state] || '?') + ' ' + n.kind);
|
||||
chain.append(chip);
|
||||
// Log link — keyed by node id, fetched on demand from /api/build-log/<node_id>.
|
||||
// `n.has_log` is set by the backend exactly when the node has a captured
|
||||
// log (equiv to old `build_log_id != null`). Lock/noop/store-only nodes
|
||||
// have has_log=false and never get a link.
|
||||
if (n.has_log) {
|
||||
chain.append(el('a', {
|
||||
class: 'rqe-log-link rqe-node-log',
|
||||
href: '/api/build-log/' + n.id + '/raw',
|
||||
target: '_blank',
|
||||
title: 'download build log for ' + n.kind + ' node',
|
||||
}, '⎙'));
|
||||
}
|
||||
const treeRoot = el('div', { class: 'rqe-nodes-tree' });
|
||||
const treeNodes = buildNodeTree(nodes);
|
||||
function renderTreeNode(n, depth, isLast, prefix) {
|
||||
const row = el('div', { class: 'rqe-tree-row' });
|
||||
if (depth > 0) {
|
||||
// prefix: the inherited connector string for ancestor columns
|
||||
// isLast: whether this node is the last sibling (use └ vs ├)
|
||||
row.append(el('span', { class: 'rqe-tree-indent' },
|
||||
prefix + (isLast ? '└─ ' : '├─ ')));
|
||||
}
|
||||
const chip = el('span', {
|
||||
class: 'rqe-node rqe-node-' + n.state,
|
||||
title: (n.agent ? n.agent + ' · ' : '') + n.kind + ' · ' + n.state
|
||||
+ (n.error ? ' — ' + n.error : ''),
|
||||
}, (QUEUE_STATE_GLYPH[n.state] || '?') + ' ' + n.kind);
|
||||
if (n.agent) {
|
||||
chip.append(el('span', { class: 'rqe-node-agent' }, ' · ' + n.agent));
|
||||
}
|
||||
row.append(chip);
|
||||
if (n.has_log) {
|
||||
row.append(el('a', {
|
||||
class: 'rqe-log-link rqe-node-log',
|
||||
href: '/api/build-log/' + n.id + '/raw',
|
||||
target: '_blank',
|
||||
title: 'download build log for ' + n.kind + ' node',
|
||||
}, '⎙'));
|
||||
}
|
||||
treeRoot.append(row);
|
||||
const childPrefix = depth > 0 ? prefix + (isLast ? ' ' : '│ ') : '';
|
||||
n._children.forEach((child, i) => {
|
||||
renderTreeNode(child, depth + 1, i === n._children.length - 1, childPrefix);
|
||||
});
|
||||
li.append(chain);
|
||||
}
|
||||
treeNodes.forEach((n, i) => renderTreeNode(n, 0, i === treeNodes.length - 1, ''));
|
||||
li.append(treeRoot);
|
||||
}
|
||||
const failed = firstFailedNode(entry);
|
||||
if (failed && failed.error) {
|
||||
|
|
|
|||
|
|
@ -807,6 +807,15 @@ impl QueueInner {
|
|||
Vec::new()
|
||||
};
|
||||
let has_log = self.node_rt.get(&id).and_then(|r| r.build_log_id).is_some();
|
||||
// `node.parent` is the structural jobq parent. Top-level nodes
|
||||
// have `parent == Some(container)` (direct children of the Dag
|
||||
// container); those become `parent: None` on the wire since the
|
||||
// container itself is not part of the work-node payload. Sub-nodes
|
||||
// carry the id of their containing parent work-node.
|
||||
let parent = node
|
||||
.parent
|
||||
.filter(|&p| p != container)
|
||||
.map(hive_jobq::NodeId::get);
|
||||
nodes.push(NodeView {
|
||||
id: id.get(),
|
||||
agent: node.payload.agent().to_owned(),
|
||||
|
|
@ -819,6 +828,7 @@ impl QueueInner {
|
|||
approval_id,
|
||||
inputs,
|
||||
has_log,
|
||||
parent,
|
||||
});
|
||||
}
|
||||
if nodes.is_empty() {
|
||||
|
|
|
|||
|
|
@ -127,6 +127,12 @@ pub struct NodeView {
|
|||
/// store-only nodes don't render a link that 404s.
|
||||
#[serde(default)]
|
||||
pub has_log: bool,
|
||||
/// Structural parent in the jobq tree — `None` for top-level nodes
|
||||
/// (direct children of the DAG container). Sub-nodes carry the id of
|
||||
/// their containing parent node. The client uses this to render the
|
||||
/// recursive tree rather than inferring structure from `deps` alone.
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub parent: Option<NodeId>,
|
||||
}
|
||||
|
||||
/// A queued / running / failed DAG — a thin projection of one container
|
||||
|
|
|
|||
Loading…
Reference in a new issue