didn't put the blocking loop in the right place for post booking

dbs/mongo/mongo.go

@@ -287,7 +287,7 @@ func (m *MongoDB) Search(filters *dbs.Filters, collection_name string) (*mongo.C
 		return nil, 503, err
 	}
 	opts := options.Find()
-	opts.SetLimit(100)
+	opts.SetLimit(1000)
 	targetDBCollection := CollectionMap[collection_name]
 	orList := bson.A{}
 	andList := bson.A{}

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

@@ -1,12 +1,13 @@
 package workflow_execution
 
 import (
-	"encoding/json"
 	"errors"
 	"fmt"
 	"strings"
+	"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"
@@ -15,6 +16,7 @@ import (
 	"cloud.o-forge.io/core/oc-lib/tools"
 	"github.com/google/uuid"
 	"github.com/robfig/cron"
+	"github.com/rs/zerolog"
 )
 
 /*
@@ -53,6 +55,8 @@ 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")
 	}
@@ -71,33 +75,69 @@ 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 _, exec := range execs {
+	for i, exec := range execs {
+		l.Debug().Msg("looping throughs execs : " + string(i))
 		bookings = append(bookings, exec.Book(ws.UUID, wfID, priceds)...)
+	}
+
+	errCh := make(chan error, len(bookings))
+	var m sync.Mutex
+
 	for _, b := range bookings {
-			// ------------ DELETE
-			fmt.Println("Booking :")
-			book, _ := json.Marshal(b)
-			fmt.Println(string(book))
-			// ----------------
+		go getBooking(l, b, request, wf, execs, bookings, errCh, &m)
+	}
+
+	for i := 0; i < len(bookings); i++ {
+		if err := <-errCh; err != nil {
+			return false, wf, execs, bookings, err
+		}
+	}
+
+	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) {
+
+	m.Lock()
+	c, err := getCallerCopy(request, errCh)
+	if err != nil {
+		errCh <- err
+		return
+	}
+	m.Unlock()
+
+	bl := l.With().Str("booking", b.UUID).Logger()
 	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)
+	bl.Debug().Msg("Get booking " + b.UUID + " on " + b.DestPeerID)
+	_, 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 {
-				return false, wf, execs, bookings, err
-			}
+		errCh <- err
+		return
 	}
 
+	errCh <- nil
+}
+
+func getCallerCopy(request *tools.APIRequest, errCh chan error) (tools.HTTPCaller, error) {
+	var c tools.HTTPCaller
+	err := request.Caller.DeepCopy(c)
+	if err != nil {
+		errCh <- err
+		return tools.HTTPCaller{}, nil
 	}
-	return true, wf, execs, bookings, nil
+	c.URLS = request.Caller.URLS
+	return c, err
 }
 
 func (ws *WorkflowSchedule) Schedules(wfID string, request *tools.APIRequest) (*WorkflowSchedule, *workflow.Workflow, []*WorkflowExecution, error) {
@@ -115,19 +155,23 @@ 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
+
+	var errCh = make(chan error, len(bookings))
+	var m sync.Mutex
+
 	for _, booking := range bookings {
-		fmt.Println("Trying to schedule on ")
-		fmt.Println(booking.DestPeerID)
-		_, err := (&peer.Peer{}).LaunchPeerExecution(booking.DestPeerID, "",
-			tools.BOOKING, tools.POST, booking.Serialize(booking), request.Caller)
-		if err != nil {
+		go ws.BookExecs(booking, request, errCh, &m)
+	}
+	
+	for i := 0; i < len(bookings); i++ {
+		if err := <- errCh ; err != nil {
 			return ws, wf, executions, errors.New("could not launch the peer execution : " + fmt.Sprintf("%v", err))
 		}
 	}
+
 	fmt.Println("Schedules")
 	for _, exec := range executions {
 		err := exec.PurgeDraft(request)
@@ -141,6 +185,30 @@ func (ws *WorkflowSchedule) Schedules(wfID string, request *tools.APIRequest) (*
 	return ws, wf, executions, nil
 }
 
+func (ws *WorkflowSchedule) BookExecs(booking *booking.Booking, request *tools.APIRequest, errCh chan error, m *sync.Mutex) {
+
+	m.Lock()
+	c, err := getCallerCopy(request, errCh)
+	if err != nil {
+		errCh <- err
+		return
+	}
+	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
+		return
+	}
+
+	errCh <- nil
+}
+
 /*
 BOOKING IMPLIED TIME, not of subscription but of execution
 so is processing time execution time applied on computes

tools/remote_caller.go

@@ -63,6 +63,16 @@ func NewHTTPCaller(urls map[DataType]map[METHOD]string) *HTTPCaller {
 	}
 }
 
+// Creates a copy of the current caller, in order to have parallelized executions without race condition 
+func (c* HTTPCaller) DeepCopy(dst HTTPCaller) error {
+	bytes, err := json.Marshal(c)
+	if err != nil {
+		return err
+	}
+
+	return json.Unmarshal(bytes, &dst)
+}
+
 // CallGet calls the GET method on the HTTP server
 func (caller *HTTPCaller) CallGet(url string, subpath string, types ...string) ([]byte, error) {
 	req, err := http.NewRequest(http.MethodGet, url+subpath, bytes.NewBuffer([]byte("")))