oc-monitord/workflow_builder/graph.go

package workflow_builder

import (
	"errors"
	"fmt"
	"maps"

	"oc-monitor/logger"
	models "oc-monitor/models"

	oclib "cloud.o-forge.io/core/oc-lib"
	"cloud.o-forge.io/core/oc-lib/models/resources/workflow/graph"
	workflow "cloud.o-forge.io/core/oc-lib/models/workflow"
)



type WorflowDB struct {
	workflow_name	string							// used to test if the graph has been instatiated, private so can only be set by a graph's method
	graph 			*graph.Graph
	links			map[int]graph.GraphLink
	ws          	models.HttpQuery
}

// Create the obj!ects from the mxgraphxml stored in the workflow given as a parameter
func (w *WorflowDB) LoadFrom(workflow_id string) error {
	
	new_wf, err := w.getWorkflow(workflow_id)
	if err != nil {
		return err
	}

	w.graph = new_wf.Graph 
	w.links = w.getLinks()

	w.workflow_name = new_wf.Name
	
	return nil
}

// Use oclib to retrieve the graph contained in the workflow referenced
func (w *WorflowDB) getWorkflow( workflow_id string) (workflow *workflow.Workflow, err error) {

	lib_data := oclib.LoadOne(oclib.LibDataEnum(oclib.WORKFLOW),workflow_id)
	if lib_data.Code != 200 {
		logger.Logger.Error().Msg("Error loading the graph")
		return workflow, errors.New(lib_data.Err)
	}

	new_wf := lib_data.ToWorkflow()
	if new_wf == nil {
		logger.Logger.Error().Msg("WorflowDB object is empty for " + workflow_id )
		return workflow, errors.New("WorflowDB can't be empty")
	}

	return new_wf, nil
}



func (w *WorflowDB) getLinks()  map[int]graph.GraphLink {
	links := make(map[int]graph.GraphLink)
	for i, link := range(w.graph.Links) {
		links[i] = link
	}

	return links
}

func (w *WorflowDB) ExportToArgo() (string, error) {
	if len(w.workflow_name) == 0 || &w.graph == nil {
		return "",fmt.Errorf("can't export a graph that has not been loaded yet")
	}
	end_links := make(map[int]graph.GraphLink)
	
	for i, link := range w.links {
		if (!w.isDCLink(i) && !w.isSource(link.Destination.ID,i)){
			end_links[i] = link
		}
	}
	
	// index_list := make([]int, len(w.links))
	// list_branches := make([][]string,0)
	list_branches := w.getListBranches(end_links, nil,nil)
		
	// for _, branch := range list_branches{
	// 	str := ""
	// 	for _, link := range branch{
	// 		str =  str + " --> " + w.getComponentName(w.graph.Links[link].Source) + " linked with " + w.getComponentName(w.links[link].Destination) 
	// 	}

	// 	fmt.Println(str)
	// }

	fmt.Println("Identified branches : ", list_branches)
	argo_builder := ArgoBuilder{graph : *w.graph, branches:  list_branches}
	filename, err := argo_builder.CreateDAG()
	if err != nil {
		logger.Logger.Error().Msg("Could not create the argo file for " + w.workflow_name)
		return "", err
	}
 	return filename, nil
}

// Return a list containing the IDs of each link that make up a branch in the graph
func (w *WorflowDB) getListBranches(end_links map[int]graph.GraphLink, unvisited_links_list map[int]graph.GraphLink, current_branch []int) (list_branches [][]int) {
	
	if current_branch == nil {
		current_branch = make([]int, 0)
	}

	if unvisited_links_list == nil {
		unvisited_links_list = make(map[int]graph.GraphLink,len(w.graph.Links))
		maps.Copy(unvisited_links_list,w.links)
		fmt.Println(unvisited_links_list)
	}
	
	for link_id, _ := range end_links {
		j := link_id
		new_branches := make([][]int,0)

		previous_index := w.getPreviousLink(j, unvisited_links_list)
		if len(previous_index) == 0 {
			list_branches = append(list_branches, []int{link_id})
		}

		for _, id_link := range previous_index {
			current_branch = append([]int{link_id},current_branch...)
			delete(unvisited_links_list, link_id)
			// create a new branch for each previous link, appending the current path to this node to the created branch
			new_end_link := make(map[int]graph.GraphLink,0)
			new_end_link[id_link] = w.links[id_link]
			new_branches = w.getListBranches(new_end_link,unvisited_links_list,current_branch)		
				
			for _, new_branch := range new_branches{
				current_branch = append(new_branch,link_id)
				list_branches = append(list_branches, current_branch)
			}
		}
	}

	return 
}

func (w *WorflowDB) ExportToHelm(id string) error {

	return nil
}

// Return if it exists a link where Destination is the same as comp_id
func (w *WorflowDB) isDestination(comp_id string,link_id int) bool {
	
	for i, link := range w.links{
		if(i !=link_id && link.Destination.ID == comp_id){
			return true
		}
	}
	
	return false
	
}

// Return if it exists a link where Source is the same as comp_id
func (w *WorflowDB) isSource(comp_id string, link_id int) bool {
	
	for i, link := range w.links{
		if(i !=link_id && link.Source.ID == comp_id && !w.isDCLink(i)){
			return true
		}
	}
	
	return false
	
}

// Returns an index number if their is a link in w.links
// with the same Destination id that the Source id in w.links[linkIndex]
// or nil if not

func (w *WorflowDB) getPreviousLink(link_id int,map_link map[int]graph.GraphLink) (previous_id []int) {
	for k, link := range map_link{
		if(k != link_id && link.Destination == w.links[link_id].Source){
			previous_id = append(previous_id, k)
		}
	}
	
	return 
}



// returns either computing, data or storage
func GetComponentType(component_id string) string {
	if libdata := oclib.LoadOne(oclib.LibDataEnum(oclib.PROCESSING_RESOURCE),component_id); libdata.Code == 200{
		return "computing"
	}
	
	if libdata := oclib.LoadOne(oclib.LibDataEnum(oclib.DATA_RESOURCE),component_id); libdata.Code == 200{
		return "data"
	}

	if libdata := oclib.LoadOne(oclib.LibDataEnum(oclib.STORAGE_RESOURCE),component_id); libdata.Code == 200{
		return "storage"
	}

	if libdata := oclib.LoadOne(oclib.LibDataEnum(oclib.DATACENTER_RESOURCE),component_id); libdata.Code == 200{
		return "datacenter"
	}

	if libdata := oclib.LoadOne(oclib.LibDataEnum(oclib.WORKFLOW_RESOURCE),component_id); libdata.Code == 200{
		return "workflow"
	}

	return ""
}

// Returns a slice of id, in case the link is made of twice the same type of component

func (w *WorflowDB) getComponentByType(compType string, link graph.GraphLink) (ids []string){
	if(GetComponentType(link.Source.ID) == compType){
		ids = append(ids, link.Source.ID)
	}
	if(GetComponentType(link.Destination.ID) == compType){
		ids = append(ids, link.Destination.ID)
	}

	return
}

func (w *WorflowDB) isDCLink(link_id int) bool {
	link := w.links[link_id]

	dest := w.graph.Items[link.Destination.ID]
	dest_id := dest.GetAbstractRessource().GetID()
	
	source := w.graph.Items[link.Source.ID]
	source_id := source.GetAbstractRessource().GetID()
	
	return IsDatacenter(dest_id) || IsDatacenter(source_id)
}

func IsDatacenter(id string) bool {
	resource := oclib.LoadOne(oclib.LibDataEnum(oclib.DATACENTER_RESOURCE),id)
	
	return resource.Code == 200 
}