oc-lib/entrypoint.go

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", ""))
	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
}