Process services in dependency order as a graph

Signed-off-by: Nicolas De Loof <nicolas.deloof@gmail.com>

local/dependencies.go

@@ -26,37 +26,27 @@ import (
 )
 
 func inDependencyOrder(ctx context.Context, project *types.Project, fn func(context.Context, types.ServiceConfig) error) error {
-	var (
+	graph := buildDependencyGraph(project.Services)
-		scheduled []string
-		ready     []string
-	)
-	services := sortByDependency(project.Services)
 
+	eg, ctx := errgroup.WithContext(ctx)
 	results := make(chan string)
 	errors := make(chan error)
-	eg, ctx := errgroup.WithContext(ctx)
+	for len(graph) > 0 {
-	for len(ready) < len(services) {
+		for _, n := range graph.independents() {
-		for _, service := range services {
+			service := n.service
-			if contains(scheduled, service.Name) {
+			eg.Go(func() error {
-				continue
+				err := fn(ctx, service)
-			}
+				if err != nil {
-			if containsAll(ready, service.GetDependencies()) {
+					errors <- err
-				service := service
+					return err
-				scheduled = append(scheduled, service.Name)
+				}
-				eg.Go(func() error {
+				results <- service.Name
-					err := fn(ctx, service)
+				return nil
-					if err != nil {
+			})
-						errors <- err
-						return err
-					}
-					results <- service.Name
-					return nil
-				})
-			}
 		}
 		select {
 		case result := <-results:
-			ready = append(ready, result)
+			graph.resolved(result)
 		case err := <-errors:
 			return err
 		}
@@ -64,20 +54,60 @@ func inDependencyOrder(ctx context.Context, project *types.Project, fn func(cont
 	return eg.Wait()
 }
 
-// sortByDependency sort a Service slice so it can be processed in respect to dependency ordering
+type dependencyGraph map[string]node
-func sortByDependency(services types.Services) types.Services {
+
-	var sorted types.Services
+type node struct {
-	var done []string
+	service      types.ServiceConfig
-	for len(sorted) < len(services) {
+	dependencies []string
-		for _, s := range services {
+	dependent    []string
-			if contains(done, s.Name) {
+}
-				continue
+
-			}
+func (d dependencyGraph) independents() []node {
-			if containsAll(done, s.GetDependencies()) {
+	var nodes []node
-				sorted = append(sorted, s)
+	for _, node := range d {
-				done = append(done, s.Name)
+		if len(node.dependencies) == 0 {
-			}
+			nodes = append(nodes, node)
 		}
 	}
-	return sorted
+	return nodes
+}
+
+func (graph dependencyGraph) resolved(result string) {
+	for _, parent := range graph[result].dependent {
+		node := graph[parent]
+		node.dependencies = remove(node.dependencies, result)
+		graph[parent] = node
+	}
+	delete(graph, result)
+}
+
+func buildDependencyGraph(services types.Services) dependencyGraph {
+	graph := dependencyGraph{}
+	for _, s := range services {
+		graph[s.Name] = node{
+			service: s,
+		}
+	}
+
+	for _, s := range services {
+		node := graph[s.Name]
+		for _, name := range s.GetDependencies() {
+			dependency := graph[name]
+			node.dependencies = append(node.dependencies, name)
+			dependency.dependent = append(dependency.dependent, s.Name)
+			graph[name] = dependency
+		}
+		graph[s.Name] = node
+	}
+	return graph
+}
+
+func remove(slice []string, item string) []string {
+	var s []string
+	for _, i := range slice {
+		if i != item {
+			s = append(s, i)
+		}
+	}
+	return s
 }