snapshot of https://github.com/cortezaproject/corteza.git (2024.9.x, 2026-09-18; blobs > 131072B omitted)

server/pkg/envoy/graph.go

@@ -0,0 +1,302 @@
+package envoy
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/cortezaproject/corteza/server/pkg/envoy/resource"
+)
+
+type (
+	nodeMap map[*node]bool
+
+	graph struct {
+		nn       nodeSet
+		resIndex map[resource.Interface]*node
+
+		missingRefs resource.RefSet
+
+		// Config flags
+		inverted bool
+
+		processed   nodeMap
+		conflicting nodeMap
+	}
+
+	ResourceState struct {
+		Res             resource.Interface
+		Conflicting     bool
+		DepResources    []resource.Interface
+		ParentResources []resource.Interface
+	}
+)
+
+func newGraph() *graph {
+	return &graph{
+		nn:          make(nodeSet, 0, 100),
+		resIndex:    make(map[resource.Interface]*node),
+		inverted:    false,
+		processed:   make(nodeMap),
+		conflicting: make(nodeMap),
+	}
+}
+
+func (g *graph) MissingDeps() resource.RefSet {
+	return g.missingRefs
+}
+
+func (g *graph) addNode(nn ...*node) {
+	for _, n := range nn {
+		g.resIndex[n.res] = n
+	}
+	g.nn = g.nn.add(nn...)
+}
+
+func (g *graph) removeNode(nn ...*node) {
+	g.nn = g.nn.remove(nn...)
+	for _, n := range nn {
+		g.removeChild(n)
+		g.removeParent(n)
+	}
+}
+
+func (g *graph) invert() {
+	g.inverted = !g.inverted
+}
+
+func (g *graph) childNodes(n *node) nodeSet {
+	if g.inverted {
+		return n.pp
+	}
+
+	return n.cc
+}
+
+func (g *graph) parentNodes(n *node) nodeSet {
+	if g.inverted {
+		return n.cc
+	}
+
+	return n.pp
+}
+
+func (g *graph) nodes() nodeSet {
+	return g.nn
+}
+
+func (g *graph) markProcessed(n *node) {
+	g.processed = g.processed.add(n)
+}
+func (g *graph) markConflicting(n *node) {
+	g.conflicting = g.conflicting.add(n)
+}
+
+func (g *graph) NextInverted(ctx context.Context) (s *ResourceState, err error) {
+	g.inverted = true
+	defer func() {
+		g.inverted = false
+	}()
+
+	return g.Next(ctx)
+}
+
+func (g *graph) Next(ctx context.Context) (s *ResourceState, err error) {
+	upNN := g.removeProcessed(g.nodes())
+
+	// We are done here
+	if len(upNN) <= 0 {
+		return nil, nil
+	}
+
+	var nx *node
+
+	for _, upN := range upNN {
+		// We should not take into account conflicted parent nodes,
+		// as they already resolved the conflict.
+		if len(g.removeProcessed(g.removeConflicting(g.parentNodes(upN)))) <= 0 {
+			nx = upN
+			break
+		}
+	}
+
+	if nx != nil {
+		// Prepare the required context for the processing.
+		// Perform some basic cleanup.
+		es := g.prepExecState(nx, false)
+		g.markProcessed(nx)
+
+		return es, nil
+	}
+
+	// There are only conflicting nodes
+	// Try to get a cycle node to resolve the conflict
+	nx = g.findCycleNode(g.removeConflicting(upNN))
+
+	if nx == nil {
+		// This is basically impossible, unless I've messed up the algorithm
+		return nil, fmt.Errorf("could not determine non-conflicting node")
+	}
+
+	// Prepare the required context for the processing.
+	es := g.prepExecState(nx, true)
+	g.markConflicting(nx)
+
+	return es, nil
+}
+
+// findCycleNode returns the first graph node that caused a cycle
+//
+// General outline:
+//   - DFS from a start node(s)
+//   - if a child node is already in path, return that node
+//   - else return nil and cleanup the path until the first node with
+//     unprocessed child nodes
+//
+// @note we could complicate this further by doing cycle enumeration algorithms.
+//
+//	I might do it when no one is watching :)
+func (g *graph) findCycleNode(nn nodeSet) *node {
+	path := make(nodeMap)
+	processed := make(nodeMap)
+
+	for _, n := range nn {
+		if !processed.has(n) {
+			m := g.traverse(n, path, processed)
+			if m != nil {
+				return m
+			}
+		}
+	}
+
+	return nil
+}
+
+func (g *graph) traverse(n *node, path, processed nodeMap) *node {
+	processed.add(n)
+
+	// Found ourselves a cycle
+	if path.has(n) {
+		return n
+	}
+	cnn := g.removeProcessed(g.removeConflicting(g.childNodes(n)))
+	// Nothing else to look at
+	if len(cnn) == 0 {
+		return nil
+	}
+
+	path.add(n)
+
+	for _, c := range cnn {
+		m := g.traverse(c, path, processed)
+		if m != nil {
+			return m
+		}
+	}
+
+	path.remove(n)
+	return nil
+}
+
+// util
+
+func (g *graph) removeProcessed(nn nodeSet) nodeSet {
+	mm := make(nodeSet, 0, len(nn))
+
+	for _, n := range nn {
+		if !g.processed.has(n) {
+			mm = mm.add(n)
+		}
+	}
+
+	return mm
+}
+
+func (g *graph) removeConflicting(nn nodeSet) nodeSet {
+	mm := make(nodeSet, 0, len(nn))
+
+	for _, n := range nn {
+		if !g.conflicting.has(n) {
+			mm = mm.add(n)
+		}
+	}
+
+	return mm
+}
+
+func (g *graph) addChild(n *node, mm ...*node) {
+	if g.inverted {
+		n.pp = n.pp.add(mm...)
+	} else {
+		n.cc = n.cc.add(mm...)
+	}
+}
+
+func (g *graph) removeChild(n *node, mm ...*node) {
+	if len(mm) <= 0 {
+		if g.inverted {
+			n.pp = make(nodeSet, 0, 10)
+		} else {
+			n.cc = make(nodeSet, 0, 10)
+		}
+	} else {
+		if g.inverted {
+			n.pp = n.pp.remove(mm...)
+		} else {
+			n.cc = n.cc.remove(mm...)
+		}
+	}
+}
+
+func (g *graph) addParent(n *node, mm ...*node) {
+	if g.inverted {
+		n.cc = n.cc.add(mm...)
+	} else {
+		n.pp = n.pp.add(mm...)
+	}
+}
+
+func (g *graph) removeParent(n *node, mm ...*node) {
+	if len(mm) <= 0 {
+		if g.inverted {
+			n.cc = make(nodeSet, 0, 10)
+		} else {
+			n.pp = make(nodeSet, 0, 10)
+		}
+	} else {
+		if g.inverted {
+			n.cc = n.cc.remove(mm...)
+		} else {
+			n.pp = n.pp.remove(mm...)
+		}
+	}
+}
+
+func (g *graph) nodeResource(nn ...*node) []resource.Interface {
+	rr := make([]resource.Interface, 0, len(nn))
+	for _, n := range nn {
+		rr = append(rr, n.res)
+	}
+
+	return rr
+}
+
+func (g *graph) prepExecState(n *node, conflicting bool) *ResourceState {
+	return &ResourceState{
+		Res:             n.res,
+		DepResources:    g.nodeResource(g.childNodes(n)...),
+		ParentResources: g.nodeResource(g.parentNodes(n)...),
+		Conflicting:     conflicting,
+	}
+}
+
+func (nm nodeMap) add(n *node) nodeMap {
+	nm[n] = true
+	return nm
+}
+func (nm nodeMap) has(n *node) bool {
+	return nm[n]
+}
+func (nm nodeMap) remove(n *node) nodeMap {
+	delete(nm, n)
+	return nm
+}