generates the steps of a dag yaml

argo_builder.go

@@ -0,0 +1,108 @@
+// A class that translates the informations held in the graph object
+// via its lists of components into an argo file, using the a list of
+// link ID to build the dag
+
+package main
+
+import (
+	"fmt"
+	"slices"
+
+	"github.com/beego/beego/v2/core/logs"
+	"gopkg.in/yaml.v3"
+)
+
+type ArgoBuilder struct {
+	graph		Graph
+	branches	[][]string
+	steps		[]DagStep
+}
+
+type DagStep struct {
+	Name			string		`yaml:"name"`
+	Template		string		`yaml:"template"`
+	Arguments		[]string	`yaml:"arguments"`
+	Dependencies	[]string	`yaml:"dependencies"`
+}
+
+
+
+func (b *ArgoBuilder) CreateDAG() bool {
+	fmt.Println("list of branches : ", b.branches)
+
+	b.createDAGstep()
+	yamlified, err := yaml.Marshal(b.steps)
+
+	if err != nil {
+		logs.Error("Could not produce yaml file")
+	}
+	fmt.Println(string(yamlified))
+
+	return true
+}
+
+
+
+func (b *ArgoBuilder) createDAGstep() {
+	for _, comp := range b.graph.Computings{
+		unique_name := comp.Name + "_" + comp.ID
+		step := DagStep{Name: unique_name, Template: unique_name, Arguments: comp.Arguments}
+		// For each branch, check if the computing has a dependency
+		for _, branch := range b.branches {
+			if b.componentInBranch(comp.ID,branch) {
+			// retrieves the name (computing.name_computing.ID)
+				dependency := b.getDependency(comp.ID,branch)
+				if dependency != "" && !slices.Contains(step.Dependencies,dependency) {	
+					step.Dependencies = append(step.Dependencies,dependency)
+				}
+			}
+		}
+		b.steps = append(b.steps, step)
+	}
+}
+
+func (b *ArgoBuilder) getDependency (current_computing_id string, branch []string) string {
+	
+	for i := len(branch)-1; i >= 0 ; i-- {
+		current_link := b.graph.Links[branch[i]]
+		current_computing_found := false
+
+		if current_link.Source == current_computing_id || current_link.Destination == current_computing_id {
+			current_computing_found = true
+		}
+
+		if current_computing_found {
+			return b.findPreviousComputing(current_computing_id,branch,i-1)
+		}
+	}
+	
+	return ""
+
+}
+
+func (b *ArgoBuilder) componentInBranch(component_id string, branch []string) bool {
+	for _, link := range branch {
+		if b.graph.Links[link].Source == component_id || b.graph.Links[link].Destination == component_id {
+			return true
+		}
+	}
+	return false
+}
+
+func (b *ArgoBuilder) findPreviousComputing(computing_id string, branch []string, index int) string {
+	
+	for i := index; i >= 0 ; i-- {
+		previousLink := b.graph.Links[branch[i]]
+
+		if previousLink.Source != computing_id && b.graph.getComponentType(previousLink.Source) == "computing"{
+			name := b.graph.getComponentName(previousLink.Source) + "_" + previousLink.Source
+			return name
+		}
+		if previousLink.Destination != computing_id && b.graph.getComponentType(previousLink.Destination) == "computing"{
+			name := b.graph.getComponentName(previousLink.Destination) + "_" + previousLink.Destination
+			return name
+		}
+
+	}
+	return ""
+}