package workflow import ( "errors" "time" "cloud.o-forge.io/core/oc-lib/models/collaborative_area/shallow_collaborative_area" "cloud.o-forge.io/core/oc-lib/models/common/pricing" "cloud.o-forge.io/core/oc-lib/models/peer" "cloud.o-forge.io/core/oc-lib/models/resources" "cloud.o-forge.io/core/oc-lib/models/utils" "cloud.o-forge.io/core/oc-lib/models/workflow/graph" "cloud.o-forge.io/core/oc-lib/tools" ) /* * AbstractWorkflow is a struct that represents a workflow for resource or native workflow * Warning: there is 2 types of workflows, the resource workflow and the native workflow * native workflow is the one that you create to schedule an execution * resource workflow is the one that is created to set our native workflow in catalog */ type AbstractWorkflow struct { resources.ResourceSet Graph *graph.Graph `bson:"graph,omitempty" json:"graph,omitempty"` // Graph UI & logic representation of the workflow ScheduleActive bool `json:"schedule_active" bson:"schedule_active"` // ScheduleActive is a flag that indicates if the schedule is active, if not the workflow is not scheduled and no execution or booking will be set // Schedule *WorkflowSchedule `bson:"schedule,omitempty" json:"schedule,omitempty"` // Schedule is the schedule of the workflow Shared []string `json:"shared,omitempty" bson:"shared,omitempty"` // Shared is the ID of the shared workflow } func (d *Workflow) GetAccessor(request *tools.APIRequest) utils.Accessor { return NewAccessor(request) // Create a new instance of the accessor } func (w *AbstractWorkflow) GetGraphItems(f func(item graph.GraphItem) bool) (list_datas []graph.GraphItem) { for _, item := range w.Graph.Items { if f(item) { list_datas = append(list_datas, item) } } return } func (w *AbstractWorkflow) GetResources(f func(item graph.GraphItem) bool) map[string]resources.ShallowResourceInterface { list_datas := map[string]resources.ShallowResourceInterface{} for _, item := range w.Graph.Items { if f(item) { res := item.GetResource() list_datas[res.GetID()] = res } } return list_datas } func (w *AbstractWorkflow) GetPricedItem(f func(item graph.GraphItem) bool) map[string]pricing.PricedItemITF { list_datas := map[string]pricing.PricedItemITF{} for _, item := range w.Graph.Items { if f(item) { res := item.GetResource() ord := item.GetPricedItem() list_datas[res.GetID()] = ord } } return list_datas } func (w *AbstractWorkflow) GetByRelatedProcessing(processingID string, g func(item graph.GraphItem) bool) []resources.ShallowResourceInterface { storages := []resources.ShallowResourceInterface{} for _, link := range w.Graph.Links { nodeID := link.Destination.ID var node resources.ShallowResourceInterface if g(w.Graph.Items[link.Source.ID]) { item := w.Graph.Items[link.Source.ID] node = item.GetResource() } if node == nil && g(w.Graph.Items[link.Destination.ID]) { // if the source is not a storage, we consider that the destination is the storage nodeID = link.Source.ID item := w.Graph.Items[link.Destination.ID] // and the processing is the source node = item.GetResource() // we are looking for the storage as destination } if processingID == nodeID && node != nil { // if the storage is linked to the processing storages = append(storages, node) } } return storages } func (wf *AbstractWorkflow) IsProcessing(item graph.GraphItem) bool { return item.Processing != nil } func (wf *AbstractWorkflow) IsCompute(item graph.GraphItem) bool { return item.Compute != nil } func (wf *AbstractWorkflow) IsData(item graph.GraphItem) bool { return item.Data != nil } func (wf *AbstractWorkflow) IsStorage(item graph.GraphItem) bool { return item.Storage != nil } func (wf *AbstractWorkflow) IsWorkflow(item graph.GraphItem) bool { return item.Workflow != nil } /* * Workflow is a struct that represents a workflow * it defines the native workflow */ type Workflow struct { utils.AbstractObject // AbstractObject contains the basic fields of an object (id, name) AbstractWorkflow // AbstractWorkflow contains the basic fields of a workflow } func (w *Workflow) GetNearestStart(start time.Time) float64 { near := float64(10000000000) for _, item := range w.Graph.Items { if item.GetResource().GetLocationStart() == nil { continue } newS := item.GetResource().GetLocationStart() if newS.Sub(start).Seconds() < near { near = newS.Sub(start).Seconds() } // get the nearest start from start var } return near } func (w *Workflow) GetLongestTime(end *time.Time) float64 { if end == nil { return -1 } longestTime := float64(0) for _, item := range w.GetGraphItems(w.IsProcessing) { if item.GetResource().GetLocationEnd() == nil { continue } newS := item.GetResource().GetLocationEnd() if longestTime < newS.Sub(*end).Seconds() { longestTime = newS.Sub(*end).Seconds() } // get the nearest start from start var } return longestTime } func (ao *Workflow) VerifyAuth(request *tools.APIRequest) bool { isAuthorized := false if len(ao.Shared) > 0 { for _, shared := range ao.Shared { shared, code, _ := shallow_collaborative_area.NewAccessor(request).LoadOne(shared) if code != 200 || shared == nil { isAuthorized = false } isAuthorized = shared.VerifyAuth(request) } } return ao.AbstractObject.VerifyAuth(request) || isAuthorized } /* * CheckBooking is a function that checks the booking of the workflow on peers (even ourselves) */ func (wfa *Workflow) CheckBooking(caller *tools.HTTPCaller) (bool, error) { // check if if wfa.Graph == nil { // no graph no booking return false, nil } accessor := (&resources.ComputeResource{}).GetAccessor(&tools.APIRequest{Caller: caller}) for _, link := range wfa.Graph.Links { if ok, compute_id := link.IsComputeLink(*wfa.Graph); ok { // check if the link is a link between a compute and a resource compute, code, _ := accessor.LoadOne(compute_id) if code != 200 { continue } // CHECK BOOKING ON PEER, compute could be a remote one peerID := compute.(*resources.ComputeResource).CreatorID if peerID == "" { return false, errors.New("no peer id") } // no peer id no booking, we need to know where to book _, err := (&peer.Peer{}).LaunchPeerExecution(peerID, compute_id, tools.BOOKING, tools.GET, nil, caller) if err != nil { return false, err } } } return true, nil }