oui ok

models/peer/peer_cache.go

@@ -93,10 +93,10 @@ func (p *PeerCache) LaunchPeerExecution(peerID string, dataID string,
 		}
 		mypeer.AddExecution(*pexec)
 		NewShallowAccessor().UpdateOne(mypeer, peerID) // Update the peer in the db
-		return nil, errors.New("peer is not reachable")
+		return nil, errors.New("peer is " + peerID + " not reachable")
 	} else {
 		if mypeer == nil {
-			return nil, errors.New("peer not found")
+			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

models/workflow/workflow.go

@@ -2,7 +2,6 @@ package workflow
 
 import (
 	"errors"
-	"fmt"
 	"time"
 
 	"cloud.o-forge.io/core/oc-lib/models/collaborative_area/shallow_collaborative_area"
@@ -111,7 +110,6 @@ func (wfa *Workflow) CheckBooking(caller *tools.HTTPCaller) (bool, error) {
 	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
-			fmt.Println("compute :" + compute_id)
 			compute, code, _ := accessor.LoadOne(compute_id)
 			if code != 200 {
 				continue

models/workflow_execution/workflow_execution.go

@@ -112,6 +112,8 @@ func (d *WorkflowExecution) VerifyAuth(request *tools.APIRequest) bool {
 func (d *WorkflowExecution) Book(executionsID string, wfID string, priceds map[tools.DataType]map[string]pricing.PricedItemITF) []*booking.Booking {
 	booking := d.bookEach(executionsID, wfID, tools.STORAGE_RESOURCE, priceds[tools.STORAGE_RESOURCE])
 	booking = append(booking, d.bookEach(executionsID, wfID, tools.PROCESSING_RESOURCE, priceds[tools.PROCESSING_RESOURCE])...)
+	booking = append(booking,d.bookEach(executionsID, wfID, tools.COMPUTE_RESOURCE, priceds[tools.COMPUTE_RESOURCE])...)
+	booking = append(booking,d.bookEach(executionsID, wfID, tools.DATA_RESOURCE, priceds[tools.DATA_RESOURCE])...)
 	return booking
 }
 

models/workflow_execution/workflow_scheduler.go

@@ -7,6 +7,7 @@ import (
 	"strings"
 	"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"
@@ -79,17 +80,11 @@ func (ws *WorkflowSchedule) CheckBooking(wfID string, request *tools.APIRequest)
 	for _, exec := range execs {
 		bookings = append(bookings, exec.Book(ws.UUID, wfID, priceds)...)
 		for _, b := range bookings {
-			// ------------ DELETE
-			fmt.Println("Booking :")
-			book, _ := json.Marshal(b)
-			fmt.Println(string(book))
-			// ----------------
 			meth := request.Caller.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
-			fmt.Println("Peer exec on " + b.DestPeerID)
 			_, err := (&peer.Peer{}).LaunchPeerExecution(b.DestPeerID, b.ResourceID, tools.BOOKING, tools.GET, nil, request.Caller)
 			if err != nil {
 				return false, wf, execs, bookings, err
@@ -115,13 +110,12 @@ func (ws *WorkflowSchedule) Schedules(wfID string, request *tools.APIRequest) (*
 	ok, wf, executions, bookings, err := ws.CheckBooking(wfID, request)
 	ws.WorkflowExecution = executions
 	if !ok || err != nil {
-		fmt.Println("Error here when scheduling")
 		return ws, nil, executions, errors.New("could not book the workflow : " + fmt.Sprintf("%v", err))
 	}
 	ws.Workflow = wf
 	for _, booking := range bookings {
-		fmt.Println("Trying to schedule on ")
+		l := logs.GetLogger()
-		fmt.Println(booking.DestPeerID)
+		l.Info().Msg("Booking on " + booking.DestPeerID)
 		_, err := (&peer.Peer{}).LaunchPeerExecution(booking.DestPeerID, "",
 			tools.BOOKING, tools.POST, booking.Serialize(booking), request.Caller)
 		if err != nil {
@@ -160,6 +154,9 @@ func (ws *WorkflowSchedule) getExecutions(workflow *workflow.Workflow) ([]*Workf
 		return workflows_executions, err
 	}
 	for _, date := range dates {
+		fmt.Println("============")
+		fmt.Println("Date : " + fmt.Sprint(date))
+		fmt.Println("============")
 		obj := &WorkflowExecution{
 			AbstractObject: utils.AbstractObject{
 				UUID: uuid.New().String(),                                 // set the uuid of the execution
@@ -196,8 +193,17 @@ func (ws *WorkflowSchedule) getDates() ([]Schedule, error) {
 		if err != nil {
 			return schedule, errors.New("Bad cron message: " + err.Error())
 		}
+
+		toto, _ := json.MarshalIndent(sched,"","")
+		fmt.Println(string(toto))
+		s := sched.Next(ws.Start)
+		fmt.Println("s.IsZero() : " + fmt.Sprint(s.IsZero()) + "s.Before(*ws.End) : " +  fmt.Sprint(s.Before(*ws.End)) )
+		tata, _ := json.MarshalIndent(s,"","")
+		fmt.Println("s = " + string(tata) + " et ws.End = " + fmt.Sprint(ws.End))
+
 		// loop through the cron schedule to set the executions
 		for s := sched.Next(ws.Start); !s.IsZero() && s.Before(*ws.End); s = sched.Next(s) {
+			fmt.Println("next execution :" + fmt.Sprint(s))
 			e := s.Add(time.Duration(ws.DurationS) * time.Second)
 			schedule = append(schedule, Schedule{
 				Start: s,