Merge branch 'main' of https://cloud.o-forge.io/core/oc-lib into main

merge oclib

models/peer/peer_cache.go

@@ -29,28 +29,7 @@ type PeerCache struct {
 
 // urlFormat formats the URL of the peer with the data type API function
 func (p *PeerCache) urlFormat(hostUrl string, dt tools.DataType) string {
-	// localhost is replaced by the local peer URL
-	// because localhost must collide on a web request security protocol
-	/*localhost := ""
-	if strings.Contains(hostUrl, "localhost") {
-		localhost = "localhost"
-	}
-	if strings.Contains(hostUrl, "127.0.0.1") {
-		localhost = "127.0.0.1"
-	}
-	if localhost != "" {
-		r := regexp.MustCompile("(" + localhost + ":[0-9]+)")
-		t := r.FindString(hostUrl)
-		if t != "" {
-			hostUrl = strings.Replace(hostUrl, t, dt.API()+":8080/oc", -1)
-		} else {
-			hostUrl = strings.ReplaceAll(hostUrl, localhost, dt.API()+":8080/oc")
-		}
-	} else {*/
-	hostUrl = hostUrl + "/" + strings.ReplaceAll(dt.API(), "oc-", "")
-	//}
-	fmt.Println("Contacting", hostUrl)
-	return hostUrl
+	return hostUrl + "/" + strings.ReplaceAll(dt.API(), "oc-", "")
 }
 
 // checkPeerStatus checks the status of a peer
@@ -86,7 +65,7 @@ func (p *PeerCache) LaunchPeerExecution(peerID string, dataID string,
 		// If the peer is not reachable, add the execution to the failed executions list
 		pexec := &PeerExecution{
 			Method:   method.String(),
-			Url:      p.urlFormat((mypeer.Url), dt) + path,  // the url is constitued of : host URL + resource path + action path (ex : mypeer.com/datacenter/resourcetype/path/to/action)
+			Url:      p.urlFormat((mypeer.Url), dt) + path, // the url is constitued of : host URL + resource path + action path (ex : mypeer.com/datacenter/resourcetype/path/to/action)
 			Body:     body,
 			DataType: dt.EnumIndex(),
 			DataID:   dataID,
@@ -99,7 +78,7 @@ func (p *PeerCache) LaunchPeerExecution(peerID string, dataID string,
 			return nil, errors.New("peer " + peerID + " not found")
 		}
 		// If the peer is reachable, launch the execution
-		url = p.urlFormat((mypeer.Url), dt) + path       // Format the URL
+		url = p.urlFormat((mypeer.Url), dt) + path     // Format the URL
 		tmp := mypeer.FailedExecution                  // Get the failed executions list
 		mypeer.FailedExecution = []PeerExecution{}     // Reset the failed executions list
 		NewShallowAccessor().UpdateOne(mypeer, peerID) // Update the peer in the db

models/workflow/workflow.go

@@ -31,6 +31,43 @@ func (d *Workflow) GetAccessor(request *tools.APIRequest) utils.Accessor {
 	return NewAccessor(request) // Create a new instance of the accessor
 }
 
+type Deps struct {
+	Source string
+	Dest   string
+}
+
+func (w *Workflow) isDependancy(id string) []Deps {
+	dependancyOfIDs := []Deps{}
+	for _, link := range w.Graph.Links {
+		if _, ok := w.Graph.Items[link.Destination.ID]; !ok {
+			continue
+		}
+		source := w.Graph.Items[link.Destination.ID].Processing
+		if id == link.Source.ID && source != nil {
+			dependancyOfIDs = append(dependancyOfIDs, Deps{Source: source.GetName(), Dest: link.Destination.ID})
+		}
+		sourceWF := w.Graph.Items[link.Destination.ID].Workflow
+		if id == link.Source.ID && sourceWF != nil {
+			dependancyOfIDs = append(dependancyOfIDs, Deps{Source: sourceWF.GetName(), Dest: link.Destination.ID})
+		}
+	}
+	return dependancyOfIDs
+}
+
+func (w *Workflow) GetDependencies(id string) (dependencies []Deps) {
+	for _, link := range w.Graph.Links {
+		if _, ok := w.Graph.Items[link.Source.ID]; !ok {
+			continue
+		}
+		source := w.Graph.Items[link.Source.ID].Processing
+		if id == link.Destination.ID && source != nil {
+			dependencies = append(dependencies, Deps{Source: source.GetName(), Dest: link.Source.ID})
+			continue
+		}
+	}
+	return
+}
+
 func (w *Workflow) GetGraphItems(f func(item graph.GraphItem) bool) (list_datas []graph.GraphItem) {
 	for _, item := range w.Graph.Items {
 		if f(item) {

models/workflow_execution/workflow_scheduler.go

@@ -7,7 +7,6 @@ import (
 	"sync"
 	"time"
 
-	"cloud.o-forge.io/core/oc-lib/logs"
 	"cloud.o-forge.io/core/oc-lib/models/booking"
 	"cloud.o-forge.io/core/oc-lib/models/common/enum"
 	"cloud.o-forge.io/core/oc-lib/models/peer"
@@ -16,7 +15,6 @@ import (
 	"cloud.o-forge.io/core/oc-lib/tools"
 	"github.com/google/uuid"
 	"github.com/robfig/cron"
-	"github.com/rs/zerolog"
 )
 
 /*
@@ -55,8 +53,6 @@ func NewScheduler(start string, end string, durationInS float64, cron string) *W
 }
 
 func (ws *WorkflowSchedule) CheckBooking(wfID string, request *tools.APIRequest) (bool, *workflow.Workflow, []*WorkflowExecution, []*booking.Booking, error) {
-	l := logs.GetLogger().With().Str("SchedulerID", ws.UUID).Logger()
-	l.Debug().Msg("Checking booking")
 	if request.Caller == nil && request.Caller.URLS == nil && request.Caller.URLS[tools.BOOKING] == nil || request.Caller.URLS[tools.BOOKING][tools.GET] == "" {
 		return false, nil, []*WorkflowExecution{}, []*booking.Booking{}, errors.New("no caller defined")
 	}
@@ -75,14 +71,12 @@ func (ws *WorkflowSchedule) CheckBooking(wfID string, request *tools.APIRequest)
 	if ws.End != nil && ws.Start.Add(time.Duration(longest)*time.Second).After(*ws.End) {
 		ws.Warning = "The workflow may be too long to be executed in the given time frame, we will try to book it anyway\n"
 	}
-	l.Debug().Msg("Getting executions")
 	execs, err := ws.getExecutions(wf)
 	if err != nil {
 		return false, wf, []*WorkflowExecution{}, []*booking.Booking{}, err
 	}
 	bookings := []*booking.Booking{}
-	for i, exec := range execs {
-		l.Debug().Msg("looping throughs execs : " + string(i))
+	for _, exec := range execs {
 		bookings = append(bookings, exec.Book(ws.UUID, wfID, priceds)...)
 	}
 
@@ -90,7 +84,7 @@ func (ws *WorkflowSchedule) CheckBooking(wfID string, request *tools.APIRequest)
 	var m sync.Mutex
 
 	for _, b := range bookings {
-		go getBooking(l, b, request, wf, execs, bookings, errCh, &m)
+		go getBooking(b, request, wf, execs, bookings, errCh, &m)
 	}
 
 	for i := 0; i < len(bookings); i++ {
@@ -102,7 +96,7 @@ func (ws *WorkflowSchedule) CheckBooking(wfID string, request *tools.APIRequest)
 	return true, wf, execs, bookings, nil
 }
 
-func getBooking(l zerolog.Logger, b *booking.Booking, request *tools.APIRequest, wf *workflow.Workflow, execs []*WorkflowExecution, bookings []*booking.Booking, errCh chan error, m *sync.Mutex) {
+func getBooking( b *booking.Booking, request *tools.APIRequest, wf *workflow.Workflow, execs []*WorkflowExecution, bookings []*booking.Booking, errCh chan error, m *sync.Mutex) {
 
 	m.Lock()
 	c, err := getCallerCopy(request, errCh)
@@ -112,15 +106,13 @@ func getBooking(l zerolog.Logger, b *booking.Booking, request *tools.APIRequest,
 	}
 	m.Unlock()
 
-	bl := l.With().Str("booking", b.UUID).Logger()
-	meth := request.Caller.URLS[tools.BOOKING][tools.GET]
+	meth := c.URLS[tools.BOOKING][tools.GET]
 	meth = strings.ReplaceAll(meth, ":id", b.ResourceID)
 	meth = strings.ReplaceAll(meth, ":start_date", b.ExpectedStartDate.Format("2006-01-02T15:04:05"))
 	meth = strings.ReplaceAll(meth, ":end_date", b.ExpectedEndDate.Format("2006-01-02T15:04:05"))
-	request.Caller.URLS[tools.BOOKING][tools.GET] = meth
-	bl.Debug().Msg("Get booking " + b.UUID + " on " + b.DestPeerID)
+	c.URLS[tools.BOOKING][tools.GET] = meth
 	_, err = (&peer.Peer{}).LaunchPeerExecution(b.DestPeerID, b.ResourceID, tools.BOOKING, tools.GET, nil, &c)
-	bl.Debug().Msg("Received response from Get booking " + b.UUID + " on " + b.DestPeerID)
+
 	if err != nil {
 		errCh <- err
 		return
@@ -195,11 +187,8 @@ func (ws *WorkflowSchedule) BookExecs(booking *booking.Booking, request *tools.A
 	}
 	m.Unlock()
 
-	l := logs.GetLogger().With().Str("SchedulerID", ws.UUID).Logger()
-	l.Debug().Msg("Booking " + booking.UUID + " on " + booking.DestPeerID)
 	_, err = (&peer.Peer{}).LaunchPeerExecution(booking.DestPeerID, "",
 		tools.BOOKING, tools.POST, booking.Serialize(booking), &c)
-	l.Debug().Msg("Received answer for booking " + booking.UUID + " on " + booking.DestPeerID)
 	
 	if err != nil {
 		errCh <- err

tools/api.go

@@ -7,6 +7,7 @@ import (
 
 	"cloud.o-forge.io/core/oc-lib/config"
 	"cloud.o-forge.io/core/oc-lib/dbs/mongo"
+	"cloud.o-forge.io/core/oc-lib/logs"
 	beego "github.com/beego/beego/v2/server/web"
 )
 
@@ -135,6 +136,7 @@ func (a *API) CheckRemotePeer(url string) (State, map[string]int) {
 // CheckRemoteAPIs checks the state of remote APIs from your proper OC
 func (a *API) CheckRemoteAPIs(apis []DataType) (State, map[string]string, error) {
 	// Check if the database is up
+	l := logs.GetLogger()
 	new := map[string]string{}
 	caller := NewHTTPCaller(map[DataType]map[METHOD]string{}) // Create a new http caller
 	code := 0
@@ -145,6 +147,7 @@ func (a *API) CheckRemoteAPIs(apis []DataType) (State, map[string]string, error)
 		var resp APIStatusResponse
 		b, err := caller.CallGet("http://"+api.API()+":8080", "/oc/version/status") // Call the status endpoint of the remote API (standard OC status endpoint)
 		if err != nil {
+			l.Error().Msg(api.String() + " not reachable")
 			state = REDUCED_SERVICE // If a remote API is not reachable, return reduced service
 			continue
 		}
@@ -161,6 +164,7 @@ func (a *API) CheckRemoteAPIs(apis []DataType) (State, map[string]string, error)
 		reachable = true // If the remote API is reachable, set reachable to true cause we are not dead
 	}
 	if !reachable {
+		l.Error().Msg("Peer check returned no answers")
 		state = DEAD // If no remote API is reachable, return dead, nobody is alive
 	}
 	if code > 0 {