package assigngraph import ( "fmt" "maps" "slices" "strings" "git.novox.be/novox/mesh-contracts/go/seats/nodeengine" "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshpipelinerunner" "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshwants" ) // Cycles are the cycles among the acting waits (design 47 G ยง272, ADR 0656, A-323): an entry waits for its acting parts in the step // an edge names, so acting parts that wait for each other, in one step or across steps, wait for ever unless a rule breaks the // cycle. A cycle within one step is `: a -> b -> a`; one across steps names each edge's step, `a -[compose]-> b -[place]-> a`; // each by node and module, said once from its smallest member, sorted. A holder's own inputs are no edge here (the graph gives an // acting edge only from a part to the entries it acts on, never to what the part is built from). func Cycles(entries []meshwants.AssignmentEntry) []string { type key struct{ step, at string } next := map[key][]string{} steps := map[string]bool{} for _, e := range entries { for _, edge := range e.Edges { if edge.Kind != EdgeActing { continue } k := key{edge.Step, e.Node + "/" + e.Module} next[k] = append(next[k], edge.Node+"/"+edge.Module) steps[edge.Step] = true } } var out []string for _, step := range slices.Sorted(maps.Keys(steps)) { const ( open = iota + 1 done ) state := map[string]int{} var path []string var walk func(at string) walk = func(at string) { state[at] = open path = append(path, at) for _, to := range next[key{step, at}] { switch state[to] { case 0: walk(to) case open: from := slices.Index(path, to) cycle := slices.Clone(path[from:]) // start at the smallest member so one cycle is said once, whichever member is met first lowest := slices.Index(cycle, slices.Min(cycle)) cycle = append(cycle[lowest:], cycle[:lowest]...) out = append(out, fmt.Sprintf("%s: %s -> %s", step, strings.Join(cycle, " -> "), cycle[0])) } } path = path[:len(path)-1] state[at] = done } starts := map[string]bool{} for k := range next { if k.step == step { starts[k.at] = true } } for _, at := range slices.Sorted(maps.Keys(starts)) { if state[at] == 0 { walk(at) } } } // Across steps (A-323): the shortest cycle through each entry over every acting edge, said when its edges name two steps or more. for _, hops := range cyclesThrough(entries, func(_ meshwants.AssignmentEntry, e meshwants.Edge) bool { return e.Kind == EdgeActing }) { if crossesSteps(hops) { out = append(out, hopWords(rotated(hops))) } } slices.Sort(out) return slices.Compact(out) } // HeldCycles is, by `/`, the cycle each entry lies on among the edges holds says hold it (A-323, A-330): a want held // on such a cycle is held for ever, since no rule breaks it. Each cycle starts at the entry and names each edge's step. func HeldCycles(entries []meshwants.AssignmentEntry, holds func(e meshwants.AssignmentEntry, edge meshwants.Edge) bool) map[string]string { out := map[string]string{} for at, hops := range cyclesThrough(entries, holds) { out[at] = hopWords(hops) } return out } // Engines is, by node, the module that holds the seat node-engine there, read from the acting edges' seat (A-330). func Engines(entries []meshwants.AssignmentEntry) map[string]string { out := map[string]string{} for _, e := range entries { for _, edge := range e.Edges { if edge.Kind == EdgeActing && edge.Seat == nodeengine.Seat { out[edge.Node] = edge.Module } } } return out } // Runner is the module that holds the seat mesh-pipeline-runner, read from the acting edges' seat as Engines reads the node-engine // (A-334); "" when none is read. func Runner(entries []meshwants.AssignmentEntry) string { for _, e := range entries { for _, edge := range e.Edges { if edge.Kind == EdgeActing && edge.Seat == meshpipelinerunner.Seat { return edge.Module } } } return "" } // hop is one edge of a cycle: from the entry at, in step, to the next hop's entry. type hop struct{ at, step string } // cyclesThrough is, by `/`, the shortest cycle through each entry over the edges keep takes, found within the // entry's strongly connected part, each starting at the entry. func cyclesThrough(entries []meshwants.AssignmentEntry, keep func(meshwants.AssignmentEntry, meshwants.Edge) bool) map[string][]hop { type out struct{ to, step string } next := map[string][]out{} for _, e := range entries { at := e.Node + "/" + e.Module for _, edge := range e.Edges { if keep(e, edge) { next[at] = append(next[at], out{edge.Node + "/" + edge.Module, edge.Step}) } } } for at := range next { slices.SortFunc(next[at], func(a, b out) int { return strings.Compare(a.to+"\x00"+a.step, b.to+"\x00"+b.step) }) } part := strongParts(slices.Sorted(maps.Keys(next)), func(at string) []string { var to []string for _, o := range next[at] { to = append(to, o.to) } return to }) found := map[string][]hop{} for _, start := range slices.Sorted(maps.Keys(next)) { // breadth first from start back to it, within its part prev := map[string]hop{} queue := []string{start} seen := map[string]bool{} for len(queue) > 0 && found[start] == nil { at := queue[0] queue = queue[1:] for _, o := range next[at] { if part[o.to] != part[start] { continue } if o.to == start { hops := []hop{{at, o.step}} for cur := at; cur != start; { h := prev[cur] hops = append(hops, h) cur = h.at } slices.Reverse(hops) found[start] = hops break } if !seen[o.to] { seen[o.to] = true prev[o.to] = hop{at, o.step} queue = append(queue, o.to) } } } } return found } // strongParts numbers each vertex by its strongly connected part (Tarjan). func strongParts(vertices []string, succ func(string) []string) map[string]int { index, low, part := map[string]int{}, map[string]int{}, map[string]int{} on := map[string]bool{} var stack []string n, parts := 0, 0 var visit func(v string) visit = func(v string) { index[v], low[v] = n, n n++ stack = append(stack, v) on[v] = true for _, w := range succ(v) { if _, ok := index[w]; !ok { visit(w) low[v] = min(low[v], low[w]) } else if on[w] { low[v] = min(low[v], index[w]) } } if low[v] == index[v] { parts++ for { w := stack[len(stack)-1] stack = stack[:len(stack)-1] on[w] = false part[w] = parts if w == v { break } } } } for _, v := range vertices { if _, ok := index[v]; !ok { visit(v) } } return part } func crossesSteps(hops []hop) bool { for _, h := range hops[1:] { if h.step != hops[0].step { return true } } return false } // rotated is the cycle started at its smallest member, so one cycle is said once. func rotated(hops []hop) []hop { lowest := 0 for i, h := range hops { if h.at < hops[lowest].at { lowest = i } } return append(slices.Clone(hops[lowest:]), hops[:lowest]...) } // hopWords is a cycle with each edge's step: `a -[compose]-> b -[place]-> a`. func hopWords(hops []hop) string { var b strings.Builder for _, h := range hops { fmt.Fprintf(&b, "%s -[%s]-> ", h.at, h.step) } return b.String() + hops[0].at }