108 lines
2.8 KiB
Go
108 lines
2.8 KiB
Go
// 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 ""
|
|
} |