reimported logs without import cycle

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/workflow_execution/workflow_scheduler.go

@@ -4,9 +4,9 @@ import (
 	"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"
@@ -78,22 +78,60 @@ func (ws *WorkflowSchedule) CheckBooking(wfID string, request *tools.APIRequest)
 	bookings := []*booking.Booking{}
 	for _, exec := range execs {
 		bookings = append(bookings, exec.Book(ws.UUID, wfID, priceds)...)
+	}
+
+	errCh := make(chan error, len(bookings))
+	var m sync.Mutex
+
 	for _, b := range bookings {
-			meth := request.Caller.URLS[tools.BOOKING][tools.GET]
+		go getBooking(b, request, wf, execs, bookings, errCh, &m)
-			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"))
+	for i := 0; i < len(bookings); i++ {
-			request.Caller.URLS[tools.BOOKING][tools.GET] = meth
+		if err := <-errCh; err != nil {
-			_, err := (&peer.Peer{}).LaunchPeerExecution(b.DestPeerID, b.ResourceID, tools.BOOKING, tools.GET, nil, request.Caller)
-			if err != nil {
 			return false, wf, execs, bookings, err
 		}
 	}
 
-	}
 	return true, wf, execs, bookings, nil
 }
 
+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)
+	if err != nil {
+		errCh <- err
+		return
+	}
+	m.Unlock()
+
+	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"))
+	c.URLS[tools.BOOKING][tools.GET] = meth
+	_, err = (&peer.Peer{}).LaunchPeerExecution(b.DestPeerID, b.ResourceID, tools.BOOKING, tools.GET, nil, &c)
+
+	if err != nil {
+		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
+	}
+	c.URLS = request.Caller.URLS
+	return c, err
+}
+
 func (ws *WorkflowSchedule) Schedules(wfID string, request *tools.APIRequest) (*WorkflowSchedule, *workflow.Workflow, []*WorkflowExecution, error) {
 	if request == nil {
 		return ws, nil, []*WorkflowExecution{}, errors.New("no request found")
@@ -112,15 +150,20 @@ func (ws *WorkflowSchedule) Schedules(wfID string, request *tools.APIRequest) (*
 		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 {
-		l := logs.GetLogger()
+		go ws.BookExecs(booking, request, errCh, &m)
-		l.Info().Msg("Booking on " + booking.DestPeerID)
+	}
-		_, err := (&peer.Peer{}).LaunchPeerExecution(booking.DestPeerID, "",
+	
-			tools.BOOKING, tools.POST, booking.Serialize(booking), request.Caller)
+	for i := 0; i < len(bookings); i++ {
-		if err != nil {
+		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)
@@ -134,6 +177,27 @@ 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()
+
+	_, err = (&peer.Peer{}).LaunchPeerExecution(booking.DestPeerID, "",
+		tools.BOOKING, tools.POST, booking.Serialize(booking), &c)
+	
+	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/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 {

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("")))