oc-schedulerd/graph.go

290 lines
8.0 KiB
Go

package main
import (
"encoding/json"
"fmt"
"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 {
Links []Link
Datas []models.DataModel
Computings []models.ComputingModel
Datacenters []models.DatacenterModel
Storages []models.StorageModel
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)
// 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
}
func (g *Graph) addElementByType(element map[string]interface{}) {
if element["@rType"] == "data" {
g.AddDataModel(element["@rID"].(string))
}
if element["@rType"] == "datacenter" {
g.AddDatacenterModel(element["@rID"].(string))
}
if element["@rType"] == "computing" {
g.AddComputingModel(element["@rID"].(string))
}
if element["@rType"] == "storage" {
g.AddStorageModel(element["@rID"].(string))
}
}
// 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{
component_db, ok := value.Value().(map[string]interface{})
if !ok {
fmt.Printf("error getting map from json")
}
comp_id := component_db["referenceID"].(string)
var obj interface{}
if (comp_id != "") {
component_map, _ := g.GetComponentById(component_type, comp_id)
switch component_type {
case "computing":
obj = ConstructComputingObject(id.Str,component_map,component_db)
case "data":
obj = ConstructDataObject(id.Str,component_map,component_db)
case "datacenter":
obj = ConstructDatacenterObject(id.Str,component_map,component_db)
case "storage":
obj = ConstructStorageObject(id.Str,component_map,component_db)
default :
logs.Critical("Component type doesn't match a know type : " + component_type)
}
g.AddComponentObject(component_type, obj)
}
return true
})
}
}
}
func (g *Graph) AddComponentObject(comp_type string, component interface{}){
switch comp_type {
case "computing":
g.Computings = append(g.Computings, component.(models.ComputingModel))
case "data":
g.Datas = append(g.Datas, component.(models.DataModel))
case "datacenter":
g.Datacenters = append(g.Datacenters, component.(models.DatacenterModel))
case "storage":
g.Storages = append(g.Storages, component.(models.StorageModel))
}
}
// Construct the object corresponding to component_type from its ID, retrieved in
// the xml graph, in order to merge the user input with the base model
func (g *Graph) GetComponentById(component_type string, id string) (map[string]interface{}, error) {
// TODO : Add a verification that g.ws is initialized ?
body , err := g.ws.Get("v1/"+component_type+"/"+id)
if err != nil {
return nil, err
}
comp := make(map[string]interface{})
jsonified := gjson.ParseBytes(body)
jsonified.ForEach(func(key, value gjson.Result) bool {
comp[key.Str] = value.String()
return true // keep iterating
})
return comp, nil
}
func (g *Graph) AddDataModel(id string) error {
var d models.DataModel
resp, err := g.ws.Get("v1/data/" + id)
if err != nil {
return err
}
json.Unmarshal(resp, &d)
g.Datas = append(g.Datas, d)
return nil
}
func (g *Graph) AddDatacenterModel(id string) error {
var d models.DatacenterModel
resp, err := g.ws.Get("v1/datacenter/" + id)
if err != nil {
return err
}
json.Unmarshal(resp, &d)
g.Datacenters = append(g.Datacenters, d)
return nil
}
func (g *Graph) AddComputingModel(id string) error {
var c models.ComputingModel
resp, err := g.ws.Get("v1/computing/" + id)
if err != nil {
return err
}
json.Unmarshal(resp, &c)
g.Computings = append(g.Computings, c)
return nil
}
func (g *Graph) AddStorageModel(id string) error {
var s models.StorageModel
resp, err := g.ws.Get("v1/data/" + id)
if err != nil {
return err
}
json.Unmarshal(resp, &s)
g.Storages = append(g.Storages, s)
return nil
}
func (g *Graph) ExportToArgo(id string) error {
return nil
}
func (g *Graph) ExportToHelm(id string) error {
return nil
}