package main import ( "encoding/json" "fmt" "maps" "net/url" "os" "strings" "cloud.o-forge.io/core/oc-catalog/models" "github.com/beego/beego/v2/core/logs" "github.com/sbabiv/xml2map" "github.com/tidwall/gjson" ) type Link struct { Src string Dst string } type Graph struct { Datas []models.DataModel Computings []models.ComputingModel Datacenters []models.DatacenterModel Storages []models.StorageModel Links map[string]models.Link ws HttpQuery } // Create a dictionnaries with each each existing workflow from a workspace, associated to the JSON representation of its content func (g *Graph) GetGraphList(apiurl string) (map[string]string, error) { g.ws.Init(apiurl) body, err := g.ws.Get("v1/workspace/list") if err != nil { return nil, err } workspaces := make(map[string]string) result := gjson.Get(string(body), "Workflows") result.ForEach(func(key, value gjson.Result) bool { workspaces[key.Str] = value.String() return true // keep iterating }) return workspaces, nil } // Create the objects from the mxgraphxml stored in the workflow given as a parameter func (g *Graph) LoadFrom(workspace string) error { // Extract the xmlgraph from the given workspace xml := gjson.Get(workspace, "MxgraphXML").String() decodedValue, err := url.QueryUnescape(xml) if err != nil { return err } os.WriteFile("graph.xml", []byte(decodedValue), 0660) decoder := xml2map.NewDecoder(strings.NewReader(decodedValue)) result, err := decoder.Decode() if err != nil { return err } // Retrieve the content of mxcell and object elements cells := result["mxGraphModel"].(map[string]interface{})["root"].(map[string]interface{})["mxCell"].([]map[string]interface{}) obj := result["mxGraphModel"].(map[string]interface{})["root"].(map[string]interface{})["object"] // Append the content of obj to cells depending on if it's a single key/value pair or a list of it switch v := obj.(type) { case map[string]interface{}: cells = append(cells, obj.(map[string]interface{})) _ = v // fmt.Printf("One: %v", v) case []map[string]interface{}: cells = append(cells, obj.([]map[string]interface{})...) // fmt.Printf("Many: %v", v) } // dictionnary := make(map[string]string) var idlinks []Link g.GetWorkflowComponents(workspace) g.GetLinks(workspace) for _, element := range cells { // id := element["@id"].(string) // // Case MXCell // if _, ok := element["@style"]; ok { // if _, ok2 := element["@rID"]; ok2 { // // Resolve elements // // fmt.Print(id + ": ") // // fmt.Println(element["@rID"], element["@rType"]) // // fmt.Println(element) // dictionnary[id] = element["@rID"].(string) // g.addElementByType(element) // } // } else { // // Case object : contains user's input through the GUI // if _, ok := element["mxCell"]; ok { // // Attribute values // // Extracts the cell ids // element = element["mxCell"].(map[string]interface{}) // if _, ok := element["@style"]; ok { // if _, ok2 := element["@rID"]; ok2 { // // Resolve elements // // fmt.Print(id + ": ") // // fmt.Println(element["@rID"], element["@rType"]) // // fmt.Println(element) // dictionnary[id] = element["@rID"].(string) // g.addElementByType(element) // } // } // } // } // register links if src, ok := element["@source"]; ok { //src = element["@source"].(string) idlinks = append(idlinks, Link{Src: src.(string), Dst: element["@target"].(string)}) // fmt.Println("Link: " + src.(string) + " " + element["@target"].(string)) } } // translate links // for _, link := range idlinks { // g.Links = append(g.Links, Link{Src: dictionnary[link.Src], Dst: dictionnary[link.Dst]}) // fmt.Println("Link: " + link.Src + " " + link.Dst + " : " + dictionnary[link.Src] + " " + dictionnary[link.Dst]) // } return nil } // TODO : extract all the JSON/data processing to a new object that takes // the current graph as an attribute and deals with adding new objects // to it, depending on their type // Create the objects that correspond to each component // in a workflow, combining the user input and the base components attributes func (g *Graph) GetWorkflowComponents(workflow string){ types := []string{"computing","datacenter","data","storage"} // create a constant for more maintainability OR even better get the list of all component's type for this WF for _, component_type := range types { // Retrieve the dict of component for a specific type in the workflow result := gjson.Get(workflow, component_type) if (result.Type != gjson.Null) { result.ForEach(func(id, value gjson.Result) bool{ comp_id := value.Get("referenceID").Str if (comp_id != "") { switch component_type { case "computing": g.AddComputingModel(comp_id, value, id.Str) case "data": g.AddDataModel(comp_id, value, id.Str) case "datacenter": g.AddDatacenterModel(comp_id, value, id.Str) case "storage": g.AddStorageModel(comp_id, value, id.Str) default : logs.Critical("Component type doesn't match a know type : " + component_type) } } return true }) } } } func (g *Graph) GetLinks(workflow string){ g.Links = make(map[string]models.Link) result := gjson.Get(workflow, "link") if (result.Type != gjson.Null) { result.ForEach(func(id, value gjson.Result) bool{ var l models.Link json.Unmarshal([]byte(value.Raw),&l) g.Links[id.Str] = l return true }) } } func (g *Graph) AddDataModel(id string, user_input gjson.Result, wf_id string) error { var d models.DataModel resp, err := g.ws.Get("v1/data/" + id) if err != nil { return err } json.Unmarshal(resp, &d) json.Unmarshal([]byte(user_input.Raw),&d.DataNEWModel) d.ID = wf_id g.Datas = append(g.Datas, d) return nil } func (g *Graph) AddDatacenterModel(id string, user_input gjson.Result, wf_id string) error { var d models.DatacenterModel resp, err := g.ws.Get("v1/datacenter/" + id) if err != nil { return err } json.Unmarshal(resp, &d) json.Unmarshal([]byte(user_input.Raw),&d.DatacenterNEWModel) d.ID = wf_id g.Datacenters = append(g.Datacenters, d) return nil } func (g *Graph) AddComputingModel(id string, user_input gjson.Result, wf_id string) error { var c models.ComputingModel resp, err := g.ws.Get("v1/computing/" + id) if err != nil { return err } json.Unmarshal(resp, &c) json.Unmarshal([]byte(user_input.Raw),&c.ComputingNEWModel) c.ID = wf_id g.Computings = append(g.Computings, c) return nil } func (g *Graph) AddStorageModel(id string, user_input gjson.Result, wf_id string) error { var s models.StorageModel resp, err := g.ws.Get("v1/storage/" + id) if err != nil { return err } json.Unmarshal(resp, &s) json.Unmarshal([]byte(user_input.Raw),&s.StorageNEWModel) s.ID = wf_id g.Storages = append(g.Storages, s) return nil } func (g *Graph) ExportToArgo(id string) error { end_links := make(map[string]models.Link) for i, link := range g.Links { if (!link.DCLink && !g.isSource(link.Destination,i)){ end_links[i] = link } } // index_list := make([]int, len(g.Links)) // list_branches := make([][]string,0) list_branches := g.getListBranches(end_links, nil,nil) for _, branch := range list_branches{ str := "" for _, link := range branch{ str = str + " --> " + g.getComponentName(g.Links[link].Source) + " linked with " + g.getComponentName(g.Links[link].Destination) } fmt.Println(str) } fmt.Println("Identified branches : ", list_branches) argo_builder := ArgoBuilder{graph : *g, branches: list_branches} argo_builder.CreateDAG() return nil } // Return a list containing the IDs of each link that make up a branch in the graph func (g *Graph) getListBranches(end_links map[string]models.Link, unvisited_links_list map[string]models.Link, current_branch []string) (list_branches [][]string) { if current_branch == nil { current_branch = make([]string, 0) } if unvisited_links_list == nil { unvisited_links_list = make(map[string]models.Link,len(g.Links)) maps.Copy(unvisited_links_list,g.Links) fmt.Println(unvisited_links_list) } for link_id, _ := range end_links { j := link_id new_branches := make([][]string,0) previous_index := g.getPreviousLink(j, unvisited_links_list) if len(previous_index) == 0 { list_branches = append(list_branches, []string{link_id}) } for _, id_link := range previous_index { current_branch = append([]string{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[string]models.Link,0) new_end_link[id_link] = g.Links[id_link] new_branches = g.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 (g *Graph) ExportToHelm(id string) error { return nil } // Return if it exists a link where Destination is the same as comp_id func (g *Graph) isDestination(comp_id string,link_id string) bool { for i, link := range g.Links{ if(i !=link_id && link.Destination == comp_id){ return true } } return false } // Return if it exists a link where Source is the same as comp_id func (g *Graph) isSource(comp_id string,link_id string) bool { for i, link := range g.Links{ if(i !=link_id && link.Source == comp_id && !link.DCLink){ return true } } return false } // Returns an index number if their is a link in g.Links // with the same Destination id that the Source id in g.Links[linkIndex] // or nil if not func (g *Graph) getPreviousLink(link_id string,map_link map[string]models.Link) (previous_id []string) { for k, link := range map_link{ if(k != link_id && link.Destination == g.Links[link_id].Source){ previous_id = append(previous_id, k) } } return } func (g *Graph) getComponentName(id string) string { for _, comp := range g.Computings{ if comp.ID == id { return comp.Name } } for _, storage := range g.Storages{ if storage.ID == id { return storage.Name } } for _, data := range g.Datas{ if data.ID == id { return data.Name } } return "" } func getMapKeys(m map[int]interface{}) []int { var list_keys []int for key := range m { fmt.Println("Key:", key) } return list_keys } func (g *Graph) getComponentType(component_id string) string { for _, comp := range g.Computings { if comp.ID == component_id{ return "computing" } } for _, data := range g.Datas { if data.ID == component_id{ return "data" } } for _, storage := range g.Storages { if storage.ID == component_id{ return "storage" } } return "" } // Returns a slice of id, in case the link is made of twice the same type of component func (g *Graph) getComponentByType(compType string, link models.Link) (ids []string){ if(g.getComponentType(link.Source) == compType){ ids = append(ids, link.Source) } if(g.getComponentType(link.Destination) == compType){ ids = append(ids, link.Destination) } return }