Files
pipelines/internal/tui/graph_forks.go
T

357 lines
10 KiB
Go

package tui
import (
"git.a-wan.net/alan/pipelines/internal/protocol"
"sort"
)
// Layer acyclic graphs by dependency depth, not declaration order. In cyclic
// graphs, forward branches get lanes while feedback routes retain upper arcs.
func forkColumns(graph protocol.Graph) (map[string]int, []string, map[string][]string, map[string][]string, bool) {
indices := map[string]int{}
for i, stage := range graph.Stages {
indices[stage.Key] = i
}
children, parents := map[string][]string{}, map[string][]string{}
fork := false
for _, stage := range graph.Stages {
seen := map[string]bool{}
for _, target := range stage.Edges {
if _, exists := indices[target]; !exists || seen[target] {
continue
}
seen[target] = true
children[stage.Key] = append(children[stage.Key], target)
parents[target] = append(parents[target], stage.Key)
}
sort.Slice(children[stage.Key], func(i, j int) bool { return indices[children[stage.Key][i]] < indices[children[stage.Key][j]] })
if len(children[stage.Key]) > 1 {
fork = true
}
}
if !fork {
return nil, nil, nil, nil, false
}
remaining := map[string]int{}
queue := []string{}
for _, stage := range graph.Stages {
remaining[stage.Key] = len(parents[stage.Key])
if remaining[stage.Key] == 0 {
queue = append(queue, stage.Key)
}
}
columns := map[string]int{}
order := []string{}
for len(queue) > 0 {
sort.Slice(queue, func(i, j int) bool { return indices[queue[i]] < indices[queue[j]] })
key := queue[0]
queue = queue[1:]
order = append(order, key)
for _, target := range children[key] {
columns[target] = max(columns[target], columns[key]+1)
remaining[target]--
if remaining[target] == 0 {
queue = append(queue, target)
}
}
}
if len(order) != len(graph.Stages) {
forward := protocol.Graph{}
for _, stage := range graph.Stages {
copy := protocol.Stage{Key: stage.Key, Edges: map[string]string{}}
for outcome, target := range stage.Edges {
if protocol.IsTerminal(target) || indices[target] > indices[stage.Key] {
copy.Edges[outcome] = target
}
}
forward.Stages = append(forward.Stages, copy)
}
return forkColumns(forward)
}
return columns, order, children, parents, true
}
func layoutForkGraph(graph protocol.Graph, columns map[string]int, order []string, children, parents map[string][]string) graphLayout {
r := layoutSingleRowGraph(graph) // Reuse numbering, sizes, port order, terminals.
old := map[string]graphNode{}
for _, node := range r.nodes {
old[node.key] = node
}
incoming, outgoing := map[string]int{}, map[string]int{}
for _, edge := range r.edges {
incoming[edge.target]++
outgoing[edge.source]++
}
// A deterministic spanning tree gives sibling branches disjoint leaf ranges.
// Shared descendants are subsequently centered over their incoming branches.
tree := map[string][]string{}
primary := map[string]string{}
for _, key := range order {
for _, target := range children[key] {
if _, exists := primary[target]; !exists {
primary[target] = key
tree[key] = append(tree[key], target)
}
}
}
ticks := map[string]int{}
nextLeaf := 0
var assign func(string) (int, int)
assign = func(key string) (int, int) {
if len(tree[key]) == 0 {
leaf := nextLeaf
nextLeaf++
ticks[key] = leaf * 2
return leaf, leaf
}
low, high := 0, 0
for i, target := range tree[key] {
a, b := assign(target)
if i == 0 {
low = a
}
high = b
}
ticks[key] = low + high
return low, high
}
for _, key := range order {
if _, exists := primary[key]; !exists {
assign(key)
}
}
for _, key := range order {
if len(parents[key]) > 1 {
low, high := ticks[parents[key][0]], ticks[parents[key][0]]
for _, parent := range parents[key] {
low = min(low, ticks[parent])
high = max(high, ticks[parent])
}
ticks[key] = (low + high) / 2
} else if len(parents[key]) == 1 && len(children[parents[key][0]]) == 1 {
ticks[key] = ticks[parents[key][0]]
}
}
maxColumn := 0
for _, column := range columns {
maxColumn = max(maxColumn, column)
}
outCount, inCount := make([]int, maxColumn+2), make([]int, maxColumn+2)
arcs := 0
for _, edge := range r.edges {
outCount[columns[edge.source]+1]++
if !protocol.IsTerminal(edge.target) && columns[edge.target] != columns[edge.source]+1 {
inCount[columns[edge.target]]++
arcs++
}
}
gaps, xs := make([]int, maxColumn+2), make([]int, maxColumn+1)
x := 0
for column := 0; column <= maxColumn; column++ {
gaps[column] = x
x += 2*(outCount[column]+inCount[column]) + 3
xs[column] = x
x += r.nodeWidth
}
gaps[maxColumn+1] = x
x += 2*outCount[maxColumn+1] + 3
r.width = x
maxHeight := 0
for i := 0; i < len(graph.Stages); i++ {
node := &r.nodes[i]
node.height = incoming[node.key] + outgoing[node.key] + 4
if incoming[node.key] > 0 {
node.height++
}
maxHeight = max(maxHeight, node.height)
}
stride := maxHeight + 4
for i := 0; i < len(graph.Stages); i++ {
node := &r.nodes[i]
node.x = xs[columns[node.key]]
node.y = arcs + ticks[node.key]*stride/2
}
// Irregular cross-branch merges can otherwise share a lane with an unrelated
// node. Resolve per-column collisions without changing left-to-right depth.
bottom := 0
for column := 0; column <= maxColumn; column++ {
ids := []int{}
for i := 0; i < len(graph.Stages); i++ {
if columns[r.nodes[i].key] == column {
ids = append(ids, i)
}
}
sort.SliceStable(ids, func(i, j int) bool { return r.nodes[ids[i]].y < r.nodes[ids[j]].y })
lastBottom := -4
for _, id := range ids {
node := &r.nodes[id]
node.y = max(node.y, lastBottom+4)
lastBottom = node.y + node.height
bottom = max(bottom, lastBottom)
}
}
nodes := map[string]graphNode{}
for i := 0; i < len(graph.Stages); i++ {
node := r.nodes[i]
nodes[node.key] = node
r.positions[node.key] = node.y
}
// Match port order to the lanes: upper branch first, lower branch next.
// This makes a split legible rather than crossing its two connectors.
for _, stage := range graph.Stages {
inputIDs, outputIDs := []int{}, []int{}
for i, edge := range r.edges {
if edge.target == stage.Key {
inputIDs = append(inputIDs, i)
}
if edge.source == stage.Key && !edge.bottomExit {
outputIDs = append(outputIDs, i)
}
}
sort.SliceStable(inputIDs, func(i, j int) bool {
return nodes[r.edges[inputIDs[i]].source].y < nodes[r.edges[inputIDs[j]].source].y
})
targetRow := func(id int) int {
if target, ok := nodes[r.edges[id].target]; ok {
return target.y
}
return bottom + 1
}
sort.SliceStable(outputIDs, func(i, j int) bool { return targetRow(outputIDs[i]) < targetRow(outputIDs[j]) })
node := nodes[stage.Key]
for row, id := range inputIDs {
r.edges[id].to = node.y + 3 + row
}
divider := 0
if len(inputIDs) > 0 {
divider = 1
}
for row, id := range outputIDs {
r.edges[id].from = node.y + 3 + len(inputIDs) + divider + row
}
for i, edge := range r.edges {
if edge.source == stage.Key && edge.bottomExit {
r.edges[i].from = node.y + node.height - 2
}
}
}
usedOut, usedIn := make([]int, maxColumn+2), make([]int, maxColumn+2)
arc := 0
for i := range r.edges {
edge := &r.edges[i]
source := nodes[edge.source]
gap := columns[edge.source] + 1
edge.x = gaps[gap] + 1 + 2*usedOut[gap]
usedOut[gap]++
if protocol.IsTerminal(edge.target) {
continue
}
target := nodes[edge.target]
edge.left = columns[edge.target] <= columns[edge.source]
edge.path = []graphPoint{{source.x + source.width - 1, edge.from}, {edge.x, edge.from}}
if columns[edge.target] == columns[edge.source]+1 {
edge.path = append(edge.path, graphPoint{edge.x, edge.to}, graphPoint{target.x, edge.to})
} else {
gap := columns[edge.target]
track := gaps[gap] + 1 + 2*(outCount[gap]+usedIn[gap])
usedIn[gap]++
edge.path = append(edge.path, graphPoint{edge.x, arc}, graphPoint{track, arc}, graphPoint{track, edge.to}, graphPoint{target.x, edge.to})
edge.lane = arc
arc++
}
}
failure, success := old[protocol.FailureEnd], old[protocol.SuccessEnd]
pairWidth := failure.width + success.width + 4
r.width = max(r.width, pairWidth)
failure.x = (r.width - pairWidth) / 2
success.x = failure.x + failure.width + 4
terminal := map[string]graphNode{protocol.FailureEnd: failure, protocol.SuccessEnd: success}
stridePort := lenInt(len(r.edges)) + 3
reserved := map[int]bool{}
for _, edge := range r.edges {
if edge.topEntry {
reserved[edge.x] = true
}
}
ports := map[int]int{}
for _, key := range []string{protocol.FailureEnd, protocol.SuccessEnd} {
ids := []int{}
for i, edge := range r.edges {
if edge.target == key {
ids = append(ids, i)
}
}
sort.SliceStable(ids, func(i, j int) bool { return r.edges[ids[i]].x < r.edges[ids[j]].x })
candidate := terminal[key].x + 2
for _, id := range ids {
for reserved[candidate] {
candidate++
}
ports[id] = candidate
candidate += stridePort
}
}
type span struct{ low, high int }
var lanes [][]span
for i := range r.edges {
edge := &r.edges[i]
if !edge.topEntry {
continue
}
destination := ports[i]
interval := span{min(edge.x, destination), max(edge.x, destination)}
lane := 0
for ; lane < len(lanes); lane++ {
free := true
for _, other := range lanes[lane] {
if interval.low <= other.high && other.low <= interval.high {
free = false
break
}
}
if free {
break
}
}
if lane == len(lanes) {
lanes = append(lanes, nil)
}
lanes[lane] = append(lanes[lane], interval)
edge.lane = lane
row := bottom + 2 + lane
source := nodes[edge.source]
edge.path = []graphPoint{{source.x + source.width - 1, edge.from}, {edge.x, edge.from}, {edge.x, row}, {destination, row}}
if edge.bottomExit {
center := source.x + source.width/2
exit := source.y + source.height - 1
edge.path = []graphPoint{{center, exit}, {center, exit + 1}, {edge.x, exit + 1}, {edge.x, row}, {destination, row}}
}
}
endY := bottom + len(lanes) + 3
for i := len(graph.Stages); i < len(r.nodes); i++ {
node := terminal[r.nodes[i].key]
node.y = endY
r.nodes[i] = node
r.positions[node.key] = endY
}
for i := range r.edges {
edge := &r.edges[i]
if edge.topEntry {
edge.to = endY
last := edge.path[len(edge.path)-1]
edge.path = append(edge.path, graphPoint{last.x, endY})
}
}
r.height = endY + 3
return r
}
func lenInt(value int) int {
length := 1
for value >= 10 {
length++
value /= 10
}
return length
}