printing in schedules

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(1000)
+	opts.SetLimit(100)
 	targetDBCollection := CollectionMap[collection_name]
 	orList := bson.A{}
 	andList := bson.A{}

models/booking/booking.go

@@ -4,7 +4,6 @@ import (
 	"time"
 
 	"cloud.o-forge.io/core/oc-lib/dbs"
-	"cloud.o-forge.io/core/oc-lib/logs"
 	"cloud.o-forge.io/core/oc-lib/models/common/enum"
 	"cloud.o-forge.io/core/oc-lib/models/utils"
 	"cloud.o-forge.io/core/oc-lib/tools"
@@ -40,8 +39,6 @@ func (wfa *Booking) Check(id string, start time.Time, end *time.Time, parrallelA
 		end = &e
 	}
 	accessor := NewAccessor(nil)
-	l := logs.GetLogger().With().Str("Search Check", "Booking").Logger()
-	l.Debug().Msg("Starting to search")
 	res, code, err := accessor.Search(&dbs.Filters{
 		And: map[string][]dbs.Filter{ // check if there is a booking on the same compute resource by filtering on the compute_resource_id, the state and the execution date
 			"resource_id": {{Operator: dbs.EQUAL.String(), Value: id}},
@@ -52,9 +49,6 @@ func (wfa *Booking) Check(id string, start time.Time, end *time.Time, parrallelA
 			},
 		},
 	}, "", wfa.IsDraft)
-
-	l.Debug().Msg("Search finished")
-
 	if code != 200 {
 		return false, err
 	}

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 " + peerID + " not reachable")
+		return nil, errors.New("peer is not reachable")
 	} else {
 		if mypeer == nil {
-			return nil, errors.New("peer " + peerID + " not found")
+			return nil, errors.New("peer 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,6 +2,7 @@ package workflow
 
 import (
 	"errors"
+	"fmt"
 	"time"
 
 	"cloud.o-forge.io/core/oc-lib/models/collaborative_area/shallow_collaborative_area"
@@ -110,6 +111,7 @@ 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,8 +112,6 @@ 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,10 +1,10 @@
 package workflow_execution
 
 import (
+	"encoding/json"
 	"errors"
 	"fmt"
 	"strings"
-	"sync"
 	"time"
 
 	"cloud.o-forge.io/core/oc-lib/models/booking"
@@ -78,60 +78,28 @@ 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 {
-		go getBooking(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
+		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
+			}
 		}
-	}
 
+	}
 	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")
@@ -147,23 +115,19 @@ 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 {
-		go ws.BookExecs(booking, request, errCh, &m)
-	}
-	
-	for i := 0; i < len(bookings); i++ {
-		if err := <- errCh ; err != nil {
+		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 {
 			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)
@@ -177,27 +141,6 @@ 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,9 +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"
-	"github.com/google/uuid"
 )
 
 type APIRequest struct {
@@ -136,9 +134,6 @@ 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) {
-	id := uuid.New()
-	l := logs.GetLogger().With().Str("id",id.String()).Logger()
-	l.Debug().Msg("Start checking")
 	// Check if the database is up
 	new := map[string]string{}
 	caller := NewHTTPCaller(map[DataType]map[METHOD]string{}) // Create a new http caller
@@ -147,7 +142,6 @@ func (a *API) CheckRemoteAPIs(apis []DataType) (State, map[string]string, error)
 	state := ALIVE
 	reachable := false
 	for _, api := range apis { // Check the state of each remote API in the list
-		l.Debug().Msg("Checking : " + api.String() + " at " + api.API())
 		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 {

tools/remote_caller.go

@@ -63,16 +63,6 @@ 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("")))