wip: stub structs and logic for a bundle workflow

* resolve a dependency graph
* identify the order of execution
* still working on how to represent a workflow of bundles to execute in a way that we can abstract with a driver

Signed-off-by: Carolyn Van Slyck <[email protected]>

Author: carolynvs

go.mod

@@ -60,6 +60,7 @@ require (
 	github.com/spf13/viper v1.8.1
 	github.com/stretchr/testify v1.7.1
 	github.com/xeipuuv/gojsonschema v1.2.0
+	github.com/yourbasic/graph v0.0.0-20210606180040-8ecfec1c2869
 	go.mongodb.org/mongo-driver v1.7.1
 	go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.29.0
 	go.opentelemetry.io/otel v1.7.0

go.sum

@@ -1578,6 +1578,8 @@ github.com/xi2/xz v0.0.0-20171230120015-48954b6210f8/go.mod h1:HUYIGzjTL3rfEspMx
 github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU=
 github.com/youmark/pkcs8 v0.0.0-20181117223130-1be2e3e5546d h1:splanxYIlg+5LfHAM6xpdFEAYOk8iySO56hMFq6uLyA=
 github.com/youmark/pkcs8 v0.0.0-20181117223130-1be2e3e5546d/go.mod h1:rHwXgn7JulP+udvsHwJoVG1YGAP6VLg4y9I5dyZdqmA=
+github.com/yourbasic/graph v0.0.0-20210606180040-8ecfec1c2869 h1:7v7L5lsfw4w8iqBBXETukHo4IPltmD+mWoLRYUmeGN8=
+github.com/yourbasic/graph v0.0.0-20210606180040-8ecfec1c2869/go.mod h1:Rfzr+sqaDreiCaoQbFCu3sTXxeFq/9kXRuyOoSlGQHE=
 github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=

pkg/cnab/dependencies/v2/bundle_graph.go

@@ -0,0 +1,109 @@
+package v2
+
+import (
+	"get.porter.sh/porter/pkg/cnab"
+	"github.com/yourbasic/graph"
+)
+
+// BundleGraph is a directed acyclic graph of a bundle and its dependencies
+// (which may be other bundles, or installations) It is used to resolve the
+// dependency order in which the bundles must be executed.
+type BundleGraph struct {
+	// nodeKeys is a map from the node key to its index in nodes
+	nodeKeys map[string]int
+	nodes    []Node
+	resolver DependencyResolver
+}
+
+func NewBundleGraph(resolver DependencyResolver) *BundleGraph {
+	return &BundleGraph{
+		nodeKeys: make(map[string]int),
+		resolver: resolver,
+	}
+}
+
+// RegisterNode adds the specified node to the graph
+// returning true if the node is already present.
+func (g *BundleGraph) RegisterNode(node Node) bool {
+	_, exists := g.nodeKeys[node.GetKey()]
+	if !exists {
+		nodeIndex := len(g.nodes)
+		g.nodes = append(g.nodes, node)
+		g.nodeKeys[node.GetKey()] = nodeIndex
+	}
+	return exists
+}
+
+func (g *BundleGraph) Sort() ([]Node, bool) {
+	dag := graph.New(len(g.nodes))
+	for nodeIndex, node := range g.nodes {
+		for _, depKey := range node.GetRequires() {
+			depIndex, ok := g.nodeKeys[depKey]
+			if !ok {
+				panic("oops")
+			}
+			dag.Add(nodeIndex, depIndex)
+		}
+	}
+
+	indices, ok := graph.TopSort(dag)
+	if !ok {
+		return nil, false
+	}
+
+	// Reverse the sort so that items with no dependencies are listed first
+	count := len(indices)
+	results := make([]Node, count)
+	for i, nodeIndex := range indices {
+		results[count-i-1] = g.nodes[nodeIndex]
+	}
+	return results, true
+}
+
+func (g *BundleGraph) GetNode(key string) (Node, bool) {
+	if nodeIndex, ok := g.nodeKeys[key]; ok {
+		return g.nodes[nodeIndex], true
+	}
+	return nil, false
+}
+
+// Node in a BundleGraph.
+type Node interface {
+	GetRequires() []string
+	GetKey() string
+}
+
+var _ Node = BundleNode{}
+var _ Node = InstallationNode{}
+
+// BundleNode is a Node in a BundleGraph that represents a dependency on a bundle
+// that has not yet been installed.
+type BundleNode struct {
+	Key       string
+	Reference cnab.BundleReference
+	Requires  []string // TODO: we don't need to know this while resolving, find a less confusing way of storing this so it's clear who should set it
+}
+
+func (d BundleNode) GetKey() string {
+	return d.Key
+}
+
+func (d BundleNode) GetRequires() []string {
+	return d.Requires
+}
+
+// InstallationNode is a Node in a BundleGraph that represents a dependency on an
+// installed bundle (installation).
+type InstallationNode struct {
+	Key       string
+	Namespace string
+	Name      string
+}
+
+func (d InstallationNode) GetKey() string {
+	return d.Key
+}
+
+func (d InstallationNode) GetRequires() []string {
+	return nil
+}

pkg/cnab/dependencies/v2/bundle_graph_test.go

@@ -0,0 +1,70 @@
+package v2
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestEngine_DependOnInstallation(t *testing.T) {
+	/*
+		A -> B (installation)
+		A -> C (bundle)
+		c.parameters.connstr <- B.outputs.connstr
+	*/
+
+	b := InstallationNode{Key: "b"}
+	c := BundleNode{
+		Key:      "c",
+		Requires: []string{"b"},
+	}
+	a := BundleNode{
+		Key:      "root",
+		Requires: []string{"b", "c"},
+	}
+
+	g := NewBundleGraph(TestResolver{})
+	g.RegisterNode(a)
+	g.RegisterNode(b)
+	g.RegisterNode(c)
+	sortedNodes, ok := g.Sort()
+	require.True(t, ok, "graph should not be cyclic")
+
+	gotOrder := make([]string, len(sortedNodes))
+	for i, node := range sortedNodes {
+		gotOrder[i] = node.GetKey()
+	}
+	wantOrder := []string{
+		"b",
+		"c",
+		"root",
+	}
+	assert.Equal(t, wantOrder, gotOrder)
+}
+
+/*
+✅ need to represent new dependency structure on an extended bundle wrapper
+(put in cnab-go later)
+
+need to read a bundle and make a BundleGraph
+? how to handle a param that isn't a pure assignment, e.g. connstr: ${bundle.deps.VM.outputs.ip}:${bundle.deps.SVC.outputs.port}
+? when are templates evaluated as the graph is executed (for simplicity, first draft no composition / templating)
+
+need to resolve dependencies in the graph
+* lookup against existing installations
+* lookup against semver tags in registry
+* lookup against bundle index? when would we look here? (i.e. preferred/registered implementations of interfaces)
+
+need to turn the sorted nodes into an execution plan
+execution plan needs:
+* bundle to execute and the installation it will become
+* parameters and credentials to pass
+  * sources:
+ 	root parameters/creds
+	installation outputs
+
+need to write something that can run an execution plan
+* knows how to grab sources and pass them into the bundle
+*/

pkg/cnab/dependencies/v2/bundle_puller.go

@@ -0,0 +1,17 @@
+package v2
+
+import (
+	"context"
+
+	"get.porter.sh/porter/pkg/cache"
+	"get.porter.sh/porter/pkg/cnab"
+)
+
+// BundlePuller can query and pull bundles.
+type BundlePuller interface {
+	// Pull retrieves a bundle definition.
+	Pull(ctx context.Context, ref cnab.OCIReference) (cache.CachedBundle, error)
+
+	// ListTags retrieves all tags defined for a bundle.
+	ListTags(ctx context.Context, ref cnab.OCIReference) ([]string, error)
+}