oc-lib/models/resources/resource.go

package resources

import (
	"cloud.o-forge.io/core/oc-lib/models/resources/compute"
	"cloud.o-forge.io/core/oc-lib/models/resources/data"
	"cloud.o-forge.io/core/oc-lib/models/resources/processing"
	"cloud.o-forge.io/core/oc-lib/models/resources/resource_model"
	"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"
)

// AbstractResource is the struct containing all of the attributes commons to all ressources

// Resource is the interface to be implemented by all classes inheriting from Resource to have the same behavior

// http://www.inanzzz.com/index.php/post/wqbs/a-basic-usage-of-int-and-string-enum-types-in-golang
type ResourceSet struct {
	Datas       []string `bson:"datas,omitempty" json:"datas,omitempty"`
	Storages    []string `bson:"storages,omitempty" json:"storages,omitempty"`
	Processings []string `bson:"processings,omitempty" json:"processings,omitempty"`
	Computes    []string `bson:"computes,omitempty" json:"computes,omitempty"`
	Workflows   []string `bson:"workflows,omitempty" json:"workflows,omitempty"`

	DataResources       []*data.DataResource             `bson:"-" json:"data_resources,omitempty"`
	StorageResources    []*storage.StorageResource       `bson:"-" json:"storage_resources,omitempty"`
	ProcessingResources []*processing.ProcessingResource `bson:"-" json:"processing_resources,omitempty"`
	ComputeResources    []*compute.ComputeResource       `bson:"-" json:"compute_resources,omitempty"`
	WorkflowResources   []*w.WorkflowResource            `bson:"-" json:"workflow_resources,omitempty"`
}

func (r *ResourceSet) Fill(peerID string, groups []string) {
	for k, v := range map[utils.DBObject][]string{
		(&data.DataResource{}):             r.Datas,
		(&compute.ComputeResource{}):       r.Computes,
		(&storage.StorageResource{}):       r.Storages,
		(&processing.ProcessingResource{}): r.Processings,
		(&w.WorkflowResource{}):            r.Workflows,
	} {
		for _, id := range v {
			d, _, e := k.GetAccessor(peerID, groups, nil).LoadOne(id)
			if e == nil {
				switch k.(type) {
				case *data.DataResource:
					r.DataResources = append(r.DataResources, d.(*data.DataResource))
				case *compute.ComputeResource:
					r.ComputeResources = append(r.ComputeResources, d.(*compute.ComputeResource))
				case *storage.StorageResource:
					r.StorageResources = append(r.StorageResources, d.(*storage.StorageResource))
				case *processing.ProcessingResource:
					r.ProcessingResources = append(r.ProcessingResources, d.(*processing.ProcessingResource))
				case *w.WorkflowResource:
					r.WorkflowResources = append(r.WorkflowResources, d.(*w.WorkflowResource))
				}
			}
		}
	}
}

type ItemResource struct {
	Data       *data.DataResource             `bson:"data,omitempty" json:"data,omitempty"`
	Processing *processing.ProcessingResource `bson:"processing,omitempty" json:"processing,omitempty"`
	Storage    *storage.StorageResource       `bson:"storage,omitempty" json:"storage,omitempty"`
	Compute    *compute.ComputeResource       `bson:"compute,omitempty" json:"compute,omitempty"`
	Workflow   *w.WorkflowResource            `bson:"workflow,omitempty" json:"workflow,omitempty"`
}

func (i *ItemResource) GetAbstractRessource() *resource_model.AbstractResource {

	if i.Data != nil {
		return &i.Data.AbstractResource
	}
	if i.Processing != nil {
		return &i.Processing.AbstractResource
	}
	if i.Storage != nil {
		return &i.Storage.AbstractResource
	}
	if i.Compute != nil {
		return &i.Compute.AbstractResource
	}
	if i.Workflow != nil {
		return &i.Workflow.AbstractResource
	}
	return nil
}