package oclib import ( "errors" "fmt" "runtime/debug" "cloud.o-forge.io/core/oc-lib/dbs" "cloud.o-forge.io/core/oc-lib/dbs/mongo" "cloud.o-forge.io/core/oc-lib/logs" "cloud.o-forge.io/core/oc-lib/models" "cloud.o-forge.io/core/oc-lib/models/peer" "cloud.o-forge.io/core/oc-lib/models/resource_model" "cloud.o-forge.io/core/oc-lib/models/resources/data" "cloud.o-forge.io/core/oc-lib/models/resources/datacenter" "cloud.o-forge.io/core/oc-lib/models/resources/processing" "cloud.o-forge.io/core/oc-lib/models/resources/storage" w "cloud.o-forge.io/core/oc-lib/models/resources/workflow" "cloud.o-forge.io/core/oc-lib/models/utils" w2 "cloud.o-forge.io/core/oc-lib/models/workflow" "cloud.o-forge.io/core/oc-lib/models/workflow_execution" "cloud.o-forge.io/core/oc-lib/models/workspace" shared_workspace "cloud.o-forge.io/core/oc-lib/models/workspace/shared" "cloud.o-forge.io/core/oc-lib/models/workspace/shared/rules/rule" "cloud.o-forge.io/core/oc-lib/tools" "github.com/rs/zerolog" ) type Filters = dbs.Filters type LibDataEnum int const ( INVALID LibDataEnum = iota DATA_RESOURCE = utils.DATA_RESOURCE PROCESSING_RESOURCE = utils.PROCESSING_RESOURCE STORAGE_RESOURCE = utils.STORAGE_RESOURCE DATACENTER_RESOURCE = utils.DATACENTER_RESOURCE WORKFLOW_RESOURCE = utils.WORKFLOW_RESOURCE WORKFLOW = utils.WORKFLOW WORKSPACE = utils.WORKSPACE WORKFLOW_EXECUTION = utils.WORKFLOW_EXECUTION PEER = utils.PEER SHARED_WORKSPACE = utils.SHARED_WORKSPACE RULE = utils.RULE BOOKING = utils.BOOKING ) func (d LibDataEnum) API() string { return utils.DefaultAPI[d] } func (d LibDataEnum) String() string { return utils.Str[d] } func (d LibDataEnum) EnumIndex() int { return int(d) } type LibDataShallow struct { Data []utils.ShallowDBObject `bson:"data" json:"data"` Code int `bson:"code" json:"code"` Err string `bson:"error" json:"error"` } type LibData struct { Data utils.DBObject `bson:"data" json:"data"` Code int `bson:"code" json:"code"` Err string `bson:"error" json:"error"` } var paths map[LibDataEnum]string = map[LibDataEnum]string{} func GetPaths() map[LibDataEnum]string { return paths } func GetPath(collection LibDataEnum) string { return paths[collection] } func AddPath(collection LibDataEnum, path string) { paths[collection] = path } func Init(appName string, hostname string, port string) { defer func() { if r := recover(); r != nil { tools.UncatchedError = append(tools.UncatchedError, errors.New("Panic recovered in Init : "+fmt.Sprintf("%v", r)+" - "+string(debug.Stack()))) fmt.Printf("Panic recovered in Init : %v - %v\n", r, string(debug.Stack())) } }() logs.SetAppName(appName) logs.SetLogger(logs.CreateLogger("main", "")) tools.GetConfig().Host = hostname tools.GetConfig().Port = port mongo.MONGOService.Init(models.GetModelsNames(), tools.GetConfig()) accessor := (&resource_model.ResourceModel{}).GetAccessor(nil) for _, model := range []string{utils.DATA_RESOURCE.String(), utils.PROCESSING_RESOURCE.String(), utils.STORAGE_RESOURCE.String(), utils.DATACENTER_RESOURCE.String(), utils.WORKFLOW_RESOURCE.String()} { data, code, _ := accessor.Search(nil, model) if code == 404 || len(data) == 0 { m := map[string]resource_model.Model{} if model == utils.PROCESSING_RESOURCE.String() { m["image"] = resource_model.Model{ Type: "string", ReadOnly: false, } m["command"] = resource_model.Model{ Type: "string", ReadOnly: false, } m["args"] = resource_model.Model{ Type: "string", ReadOnly: false, } } accessor.StoreOne(&resource_model.ResourceModel{ ResourceType: model, Model: m, }) } } } func GetLogger() zerolog.Logger { return logs.GetLogger() } func Search(filters *dbs.Filters, word string, collection LibDataEnum, c ...*tools.HTTPCaller) (data LibDataShallow) { defer func() { if r := recover(); r != nil { tools.UncatchedError = append(tools.UncatchedError, errors.New("Panic recovered in Search : "+fmt.Sprintf("%v", r))) data = LibDataShallow{Data: nil, Code: 500, Err: "Panic recovered in LoadAll : " + fmt.Sprintf("%v", r) + " - " + string(debug.Stack())} } }() var caller *tools.HTTPCaller if len(c) > 0 { caller = c[0] } d, code, err := models.Model(collection.EnumIndex()).GetAccessor(caller).Search(filters, word) if err != nil { data = LibDataShallow{Data: d, Code: code, Err: err.Error()} return } data = LibDataShallow{Data: d, Code: code} return } func LoadAll(collection LibDataEnum, c ...*tools.HTTPCaller) (data LibDataShallow) { defer func() { if r := recover(); r != nil { tools.UncatchedError = append(tools.UncatchedError, errors.New("Panic recovered in LoadAll : "+fmt.Sprintf("%v", r)+" - "+string(debug.Stack()))) data = LibDataShallow{Data: nil, Code: 500, Err: "Panic recovered in LoadAll : " + fmt.Sprintf("%v", r) + " - " + string(debug.Stack())} } }() var caller *tools.HTTPCaller if len(c) > 0 { caller = c[0] } d, code, err := models.Model(collection.EnumIndex()).GetAccessor(caller).LoadAll() if err != nil { data = LibDataShallow{Data: d, Code: code, Err: err.Error()} return } data = LibDataShallow{Data: d, Code: code} return } func LoadOne(collection LibDataEnum, id string, c ...*tools.HTTPCaller) (data LibData) { defer func() { if r := recover(); r != nil { tools.UncatchedError = append(tools.UncatchedError, errors.New("Panic recovered in LoadOne : "+fmt.Sprintf("%v", r)+" - "+string(debug.Stack()))) data = LibData{Data: nil, Code: 500, Err: "Panic recovered in LoadOne : " + fmt.Sprintf("%v", r) + " - " + string(debug.Stack())} } }() var caller *tools.HTTPCaller if len(c) > 0 { caller = c[0] } d, code, err := models.Model(collection.EnumIndex()).GetAccessor(caller).LoadOne(id) if err != nil { data = LibData{Data: d, Code: code, Err: err.Error()} return } data = LibData{Data: d, Code: code} return } func UpdateOne(collection LibDataEnum, set map[string]interface{}, id string, c ...*tools.HTTPCaller) (data LibData) { defer func() { if r := recover(); r != nil { tools.UncatchedError = append(tools.UncatchedError, errors.New("Panic recovered in UpdateOne : "+fmt.Sprintf("%v", r)+" - "+string(debug.Stack()))) data = LibData{Data: nil, Code: 500, Err: "Panic recovered in UpdateOne : " + fmt.Sprintf("%v", r) + " - " + string(debug.Stack())} } }() var caller *tools.HTTPCaller if len(c) > 0 { caller = c[0] } model := models.Model(collection.EnumIndex()) d, code, err := model.GetAccessor(caller).UpdateOne(model.Deserialize(set), id) if err != nil { data = LibData{Data: d, Code: code, Err: err.Error()} return } data = LibData{Data: d, Code: code} return } func DeleteOne(collection LibDataEnum, id string, c ...*tools.HTTPCaller) (data LibData) { defer func() { if r := recover(); r != nil { tools.UncatchedError = append(tools.UncatchedError, errors.New("Panic recovered in DeleteOne : "+fmt.Sprintf("%v", r)+" - "+string(debug.Stack()))) data = LibData{Data: nil, Code: 500, Err: "Panic recovered in DeleteOne : " + fmt.Sprintf("%v", r) + " - " + string(debug.Stack())} } }() var caller *tools.HTTPCaller if len(c) > 0 { caller = c[0] } d, code, err := models.Model(collection.EnumIndex()).GetAccessor(caller).DeleteOne(id) if err != nil { data = LibData{Data: d, Code: code, Err: err.Error()} return } data = LibData{Data: d, Code: code} return } func StoreOne(collection LibDataEnum, object map[string]interface{}, c ...*tools.HTTPCaller) (data LibData) { defer func() { if r := recover(); r != nil { tools.UncatchedError = append(tools.UncatchedError, errors.New("Panic recovered in StoreOne : "+fmt.Sprintf("%v", r)+" - "+string(debug.Stack()))) data = LibData{Data: nil, Code: 500, Err: "Panic recovered in StoreOne : " + fmt.Sprintf("%v", r) + " - " + string(debug.Stack())} } }() var caller *tools.HTTPCaller if len(c) > 0 { caller = c[0] } model := models.Model(collection.EnumIndex()) d, code, err := model.GetAccessor(caller).StoreOne(model.Deserialize(object)) if err != nil { data = LibData{Data: d, Code: code, Err: err.Error()} return } data = LibData{Data: d, Code: code} return } func CopyOne(collection LibDataEnum, object map[string]interface{}, c ...*tools.HTTPCaller) (data LibData) { defer func() { if r := recover(); r != nil { tools.UncatchedError = append(tools.UncatchedError, errors.New("Panic recovered in CopyOne : "+fmt.Sprintf("%v", r)+" - "+string(debug.Stack()))) data = LibData{Data: nil, Code: 500, Err: "Panic recovered in UpdateOne : " + fmt.Sprintf("%v", r) + " - " + string(debug.Stack())} } }() var caller *tools.HTTPCaller if len(c) > 0 { caller = c[0] } model := models.Model(collection.EnumIndex()) d, code, err := model.GetAccessor(caller).CopyOne(model.Deserialize(object)) if err != nil { data = LibData{Data: d, Code: code, Err: err.Error()} return } data = LibData{Data: d, Code: code} return } // ================ CAST ========================= // func (l *LibData) ToDataResource() *data.DataResource { if l.Data.GetAccessor(nil).GetType() == utils.DATA_RESOURCE.String() { return l.Data.(*data.DataResource) } return nil } func (l *LibData) ToDatacenterResource() *datacenter.DatacenterResource { if l.Data != nil && l.Data.GetAccessor(nil).GetType() == utils.DATACENTER_RESOURCE.String() { return l.Data.(*datacenter.DatacenterResource) } return nil } func (l *LibData) ToStorageResource() *storage.StorageResource { if l.Data.GetAccessor(nil).GetType() == utils.STORAGE_RESOURCE.String() { return l.Data.(*storage.StorageResource) } return nil } func (l *LibData) ToProcessingResource() *processing.ProcessingResource { if l.Data.GetAccessor(nil).GetType() == utils.PROCESSING_RESOURCE.String() { return l.Data.(*processing.ProcessingResource) } return nil } func (l *LibData) ToWorkflowResource() *w.WorkflowResource { if l.Data.GetAccessor(nil).GetType() == utils.WORKFLOW_RESOURCE.String() { return l.Data.(*w.WorkflowResource) } return nil } func (l *LibData) ToPeer() *peer.Peer { if l.Data.GetAccessor(nil).GetType() == utils.PEER.String() { return l.Data.(*peer.Peer) } return nil } func (l *LibData) ToWorkflow() *w2.Workflow { if l.Data.GetAccessor(nil).GetType() == utils.WORKFLOW.String() { return l.Data.(*w2.Workflow) } return nil } func (l *LibData) ToWorkspace() *workspace.Workspace { if l.Data.GetAccessor(nil).GetType() == utils.WORKSPACE.String() { return l.Data.(*workspace.Workspace) } return nil } func (l *LibData) ToSharedWorkspace() *shared_workspace.SharedWorkspace { if l.Data.GetAccessor(nil).GetType() == utils.SHARED_WORKSPACE.String() { return l.Data.(*shared_workspace.SharedWorkspace) } return nil } func (l *LibData) ToRule() *rule.Rule { if l.Data.GetAccessor(nil).GetType() == utils.SHARED_WORKSPACE.String() { return l.Data.(*rule.Rule) } return nil } func (l *LibData) ToWorkflowExecution() *workflow_execution.WorkflowExecution { if l.Data.GetAccessor(nil).GetType() == utils.WORKFLOW_EXECUTION.String() { return l.Data.(*workflow_execution.WorkflowExecution) } return nil }