[FAB-7378] tree utilities for service discovery

This change set adds tree utilities for service discovery,
in order to do signature policy analysis.

Tests with code coverage of 100% are included.

Change-Id: I1d42e2e45f4b25f953bb5adceb73245186a1e5d2
Signed-off-by: yacovm <yacovm@il.ibm.com>

Author: yacovm

common/graph/choose.go

@@ -0,0 +1,62 @@
+/*
+Copyright IBM Corp. All Rights Reserved.
+
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package graph
+
+type orderedSet struct {
+	elements []interface{}
+}
+
+func (s *orderedSet) add(o interface{}) {
+	s.elements = append(s.elements, o)
+}
+
+type indiceSet struct {
+	indices []int
+}
+
+type indiceSets []*indiceSet
+
+func factorial(n int) int {
+	m := 1
+	for i := 1; i <= n; i++ {
+		m *= i
+	}
+	return m
+}
+
+func nChooseK(n, k int) int {
+	a := factorial(n)
+	b := factorial(n-k) * factorial(k)
+	return a / b
+}
+
+func chooseKoutOfN(n, k int) indiceSets {
+	var res indiceSets
+	subGroups := &orderedSet{}
+	choose(n, k, 0, nil, subGroups)
+	for _, el := range subGroups.elements {
+		res = append(res, el.(*indiceSet))
+	}
+	return res
+}
+
+func choose(n int, targetAmount int, i int, currentSubGroup []int, subGroups *orderedSet) {
+	// Check if we have enough elements in our current subgroup
+	if len(currentSubGroup) == targetAmount {
+		subGroups.add(&indiceSet{indices: currentSubGroup})
+		return
+	}
+	// Return early if not enough remaining candidates to pick from
+	itemsLeftToPick := n - i
+	if targetAmount-len(currentSubGroup) > itemsLeftToPick {
+		return
+	}
+	// We either pick the current element
+	choose(n, targetAmount, i+1, append(currentSubGroup, i), subGroups)
+	// Or don't pick it
+	choose(n, targetAmount, i+1, currentSubGroup, subGroups)
+}

common/graph/choose_test.go

@@ -0,0 +1,26 @@
+/*
+Copyright IBM Corp. All Rights Reserved.
+
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package graph
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestChoose(t *testing.T) {
+	assert.Equal(t, 24, factorial(4))
+	assert.Equal(t, 1, factorial(0))
+	assert.Equal(t, 1, factorial(1))
+	assert.Equal(t, 15504, nChooseK(20, 5))
+	for n := 1; n < 20; n++ {
+		for k := 1; k < n; k++ {
+			g := chooseKoutOfN(n, k)
+			assert.Equal(t, nChooseK(n, k), len(g), "n=%d, k=%d", n, k)
+		}
+	}
+}

common/graph/perm.go

@@ -0,0 +1,116 @@
+/*
+Copyright IBM Corp. All Rights Reserved.
+
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package graph
+
+// treePermutations represents possible permutations
+// of a tree
+type treePermutations struct {
+	originalRoot           *TreeVertex                     // The root vertex of all sub-trees
+	permutations           []*TreeVertex                   // The accumulated permutations
+	descendantPermutations map[*TreeVertex][][]*TreeVertex // Defines the combinations of sub-trees based on the threshold of the current vertex
+}
+
+// newTreePermutation creates a new treePermutations object with a given root vertex
+func newTreePermutation(root *TreeVertex) *treePermutations {
+	return &treePermutations{
+		descendantPermutations: make(map[*TreeVertex][][]*TreeVertex),
+		originalRoot:           root,
+		permutations:           []*TreeVertex{root},
+	}
+}
+
+// permute returns Trees that their vertices and edges all exist in the original tree who's vertex
+// is the 'originalRoot' field of the treePermutations
+func (tp *treePermutations) permute() []*Tree {
+	tp.computeDescendantPermutations()
+
+	it := newBFSIterator(tp.originalRoot)
+	for {
+		v := it.Next()
+		if v == nil {
+			break
+		}
+
+		if len(v.Descendants) == 0 {
+			continue
+		}
+
+		// Iterate over all permutations where v exists
+		// and separate them to 2 sets: a indiceSet where it exists and a indiceSet where it doesn't
+		var permutationsWhereVexists []*TreeVertex
+		var permutationsWhereVdoesntExist []*TreeVertex
+		for _, perm := range tp.permutations {
+			if perm.Exists(v.Id) {
+				permutationsWhereVexists = append(permutationsWhereVexists, perm)
+			} else {
+				permutationsWhereVdoesntExist = append(permutationsWhereVdoesntExist, perm)
+			}
+		}
+
+		// Remove the permutations where v exists from the permutations
+		tp.permutations = permutationsWhereVdoesntExist
+
+		// Next, we replace each occurrence of a permutation where v exists,
+		// with multiple occurrences of its descendants permutations
+		for _, perm := range permutationsWhereVexists {
+			// For each permutation of v's descendants, clone the graph
+			// and create a new graph with v replaced with the permutated graph
+			// of v connected to the descendant permutation
+			for _, permutation := range tp.descendantPermutations[v] {
+				subGraph := &TreeVertex{
+					Id:          v.Id,
+					Data:        v.Data,
+					Descendants: permutation,
+				}
+				newTree := perm.Clone()
+				newTree.replace(v.Id, subGraph)
+				// Add the new option to the permutations
+				tp.permutations = append(tp.permutations, newTree)
+			}
+		}
+	}
+
+	res := make([]*Tree, len(tp.permutations))
+	for i, perm := range tp.permutations {
+		res[i] = perm.ToTree()
+	}
+	return res
+}
+
+// computeDescendantPermutations computes all possible combinations of sub-trees
+// for all vertices, based on the thresholds.
+func (tp *treePermutations) computeDescendantPermutations() {
+	it := newBFSIterator(tp.originalRoot)
+	for {
+		v := it.Next()
+		if v == nil {
+			return
+		}
+
+		// Skip leaves
+		if len(v.Descendants) == 0 {
+			continue
+		}
+
+		// Iterate over all options of selecting the threshold out of the descendants
+		for _, el := range chooseKoutOfN(len(v.Descendants), v.Threshold) {
+			// And for each such option, append it to the current TreeVertex
+			tp.descendantPermutations[v] = append(tp.descendantPermutations[v], v.selectDescendants(el.indices))
+		}
+	}
+}
+
+// selectDescendants returns a subset of descendants according to given indices
+func (v *TreeVertex) selectDescendants(indices []int) []*TreeVertex {
+	r := make([]*TreeVertex, len(indices))
+	i := 0
+	for _, index := range indices {
+		r[i] = v.Descendants[index]
+		i++
+	}
+	return r
+}

common/graph/perm_test.go

@@ -0,0 +1,63 @@
+/*
+Copyright IBM Corp. All Rights Reserved.
+
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package graph
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestF(t *testing.T) {
+	vR := NewTreeVertex("r", nil)
+	vR.Threshold = 2
+
+	vD := vR.AddDescendant(NewTreeVertex("D", nil))
+	vD.Threshold = 2
+	for _, id := range []string{"A", "B", "C"} {
+		vD.AddDescendant(NewTreeVertex(id, nil))
+	}
+
+	vE := vR.AddDescendant(NewTreeVertex("E", nil))
+	vE.Threshold = 2
+	for _, id := range []string{"a", "b", "c"} {
+		vE.AddDescendant(NewTreeVertex(id, nil))
+	}
+
+	vF := vR.AddDescendant(NewTreeVertex("F", nil))
+	vF.Threshold = 2
+	for _, id := range []string{"1", "2", "3"} {
+		vF.AddDescendant(NewTreeVertex(id, nil))
+	}
+
+	permutations := vR.ToTree().Permute()
+	// For a sub-tree with r-(D,E) we have 9 combinations (3 combinations of each sub-tree where D and E are the roots)
+	// For a sub-tree with r-(D,F) we have 9 combinations from the same logic
+	// For a sub-tree with r-(E,F) we have 9 combinations too
+	// Total 27 combinations
+	assert.Equal(t, 27, len(permutations))
+
+	listCombination := func(i Iterator) []string {
+		var traversal []string
+		for {
+			v := i.Next()
+			if v == nil {
+				break
+			}
+			traversal = append(traversal, v.Id)
+		}
+		return traversal
+	}
+
+	// First combination is a left most traversal on the combination graph
+	expectedScan := []string{"r", "D", "E", "A", "B", "a", "b"}
+	assert.Equal(t, expectedScan, listCombination(permutations[0].BFS()))
+
+	// Last combination is a right most traversal on the combination graph
+	expectedScan = []string{"r", "E", "F", "b", "c", "2", "3"}
+	assert.Equal(t, expectedScan, listCombination(permutations[26].BFS()))
+}