Bug: Fix module health status output

Add fall safe to ensure module health tree rendering output does not
panic when producing the output.

Note: This was a reported failure during ci testing where the cilium
status command failed with `panic: strings: negative Repeat count`

Signed-off-by: Fernand Galiana <[email protected]>

Author: derailed

pkg/health/client/modules_test.go

@@ -40,10 +40,10 @@ agent
 ├── a
 │   └── b
 │       └── c
-│           ├── fred                                        [OK] yo (20s, x1)
-│           │   └── blee                                    [OK] doh (20s, x1)
-│           └── dork                                        [DEGRADED] bozo -- BOOM! (20s, x1)
-└── m1                                                      [OK] status nominal (2s, x0)`,
+│           ├── fred                                            [OK] yo (20s, x1)
+│           │   └── blee                                        [OK] doh (20s, x1)
+│           └── dork                                            [DEGRADED] bozo -- BOOM! (20s, x1)
+└── m1                                                          [OK] status nominal (2s, x0)`,
 			v: true,
 		},
 	}

pkg/health/client/tree.go

@@ -78,9 +78,11 @@ func (n *node) find(val string) *node {
 }
 
 func (n *node) asBytes() []byte {
-	w := new(bytes.Buffer)
-	level := 0
-	var levelsEnded []int
+	var (
+		w           = new(bytes.Buffer)
+		levelsEnded []int
+		max         = computeMaxLevel(0, n)
+	)
 	if n.parent == nil {
 		w.WriteString(n.val)
 		if n.meta != "" {
@@ -91,12 +93,12 @@ func (n *node) asBytes() []byte {
 		edge := mid
 		if len(n.nodes) == 0 {
 			edge = end
-			levelsEnded = append(levelsEnded, level)
+			levelsEnded = append(levelsEnded, 0)
 		}
-		dumpVals(w, 0, levelsEnded, edge, n)
+		dumpVals(w, 0, max, levelsEnded, edge, n)
 	}
 	if len(n.nodes) > 0 {
-		dumpNodes(w, level, levelsEnded, n.nodes)
+		dumpNodes(w, 0, max, levelsEnded, n.nodes)
 	}
 
 	return w.Bytes()
@@ -115,21 +117,36 @@ func (n *node) lastNode() *node {
 	return n.nodes[c-1]
 }
 
-func dumpNodes(w io.Writer, level int, levelsEnded []int, nodes []*node) {
+func computeMaxLevel(level int, n *node) int {
+	if n == nil || len(n.nodes) == 0 {
+		return level
+	}
+	var max int
+	for _, n := range n.nodes {
+		m := computeMaxLevel(level+1, n)
+		if m > max {
+			max = m
+		}
+	}
+
+	return max
+}
+
+func dumpNodes(w io.Writer, level, maxLevel int, levelsEnded []int, nodes []*node) {
 	for i, node := range nodes {
 		edge := mid
 		if i == len(nodes)-1 {
 			levelsEnded = append(levelsEnded, level)
 			edge = end
 		}
-		dumpVals(w, level, levelsEnded, edge, node)
+		dumpVals(w, level, maxLevel, levelsEnded, edge, node)
 		if len(node.nodes) > 0 {
-			dumpNodes(w, level+1, levelsEnded, node.nodes)
+			dumpNodes(w, level+1, maxLevel, levelsEnded, node.nodes)
 		}
 	}
 }
 
-func dumpVals(w io.Writer, level int, levelsEnded []int, edge decoration, node *node) {
+func dumpVals(w io.Writer, level, maxLevel int, levelsEnded []int, edge decoration, node *node) {
 	for i := 0; i < level; i++ {
 		if isEnded(levelsEnded, i) {
 			fmt.Fprint(w, strings.Repeat(" ", indentSize+1))
@@ -140,7 +157,10 @@ func dumpVals(w io.Writer, level int, levelsEnded []int, edge decoration, node *
 
 	val := dumpVal(level, node)
 	if node.meta != "" {
-		c := 4 - level
+		c := maxLevel - level
+		if c < 0 {
+			c = 0
+		}
 		fmt.Fprintf(w, "%s %-"+strconv.Itoa(leafMaxWidth+c*2)+"s%s%s\n", edge, val, strings.Repeat("  ", c), node.meta)
 		return
 	}

pkg/health/client/tree_test.go

@@ -9,6 +9,49 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
+func TestComputeMaxLevel(t *testing.T) {
+	uu := map[string]struct {
+		n   *node
+		max int
+	}{
+		"empty": {},
+		"single": {
+			n: &node{val: "n1", meta: "m1"},
+		},
+		"flat": {
+			n: &node{val: "n1", meta: "m1", nodes: []*node{
+				{val: "n2", meta: "m2"},
+				{val: "n3", meta: "m3"},
+			}},
+			max: 1,
+		},
+		"multi": {
+			n: &node{val: "n1", meta: "m1", nodes: []*node{
+				{val: "n1_1", meta: "m1_1", nodes: []*node{
+					{val: "n1_1_1", meta: "m1_1_1", nodes: []*node{
+						{val: "n1_1_1_1", meta: "m1_1_1_1"},
+						{val: "n1_1_1_2", meta: "m1_1_1_2"},
+					}},
+				}},
+				{val: "n2", meta: "m2", nodes: []*node{
+					{val: "n2_1", meta: "m2_1", nodes: []*node{
+						{val: "n2_1_1", meta: "m2_1_1"},
+					}},
+				}},
+				{val: "n3", meta: "m3"},
+			}},
+			max: 3,
+		},
+	}
+
+	for k := range uu {
+		u := uu[k]
+		t.Run(k, func(t *testing.T) {
+			assert.Equal(t, u.max, computeMaxLevel(0, u.n))
+		})
+	}
+}
+
 func TestTreeAddNode(t *testing.T) {
 	r := newRoot("fred")
 	r.addNode("a")
@@ -17,7 +60,13 @@ func TestTreeAddNode(t *testing.T) {
 	r.addNode("c")
 	r.addNodeWithMeta("d", "blee")
 
-	assert.Equal(t, "fred\n├── a\n├── b\n│   └── b1\n├── c\n└── d                                                       blee\n", r.String())
+	assert.Equal(t, `fred
+├── a
+├── b
+│   └── b1
+├── c
+└── d                                               blee
+`, r.String())
 }
 
 func TestTreeAddBranch(t *testing.T) {
@@ -29,7 +78,14 @@ func TestTreeAddBranch(t *testing.T) {
 	r.addBranch("c")
 	r.addBranchWithMeta("d", "blee")
 
-	assert.Equal(t, "fred\n├── a\n├── b\n│   └── b1\n│       └── b1_1\n├── c\n└── d                                                       blee\n", r.String())
+	assert.Equal(t, `fred
+├── a
+├── b
+│   └── b1
+│       └── b1_1
+├── c
+└── d                                                   blee
+`, r.String())
 }
 
 func TestTreeFind(t *testing.T) {