Proper checkUp

infrastructure/nats.go

@@ -5,16 +5,12 @@ import (
 	"encoding/json"
 	"fmt"
 	"oc-scheduler/conf"
-	"sync"
-	"time"
 
 	oclib "cloud.o-forge.io/core/oc-lib"
-	"cloud.o-forge.io/core/oc-lib/config"
 	"cloud.o-forge.io/core/oc-lib/models/booking"
 	"cloud.o-forge.io/core/oc-lib/models/resources/purchase_resource"
 	"cloud.o-forge.io/core/oc-lib/models/utils"
 	"cloud.o-forge.io/core/oc-lib/tools"
-	"github.com/nats-io/nats.go"
 )
 
 // ---------------------------------------------------------------------------
@@ -43,42 +39,14 @@ func EmitNATS(peerID string, message tools.PropalgationMessage) {
 
 func ListenNATS() {
 	tools.NewNATSCaller().ListenNats(map[tools.NATSMethod]func(tools.NATSResponse){
-		tools.PLANNER_EXECUTION: handlePlannerExecution,
+		tools.PLANNER_EXECUTION:  handlePlannerExecution,
 		tools.PROPALGATION_EVENT: handlePropagationEvent,
-		tools.REMOVE_RESOURCE:   handleRemoveResource,
-		tools.CREATE_RESOURCE:   handleCreateResource,
+		tools.REMOVE_RESOURCE:    handleRemoveResource,
+		tools.CREATE_RESOURCE:    handleCreateResource,
+		tools.CONFIRM_EVENT:      handleConfirm,
 	})
 }
 
-// ---------------------------------------------------------------------------
-// Confirm channels
-// ---------------------------------------------------------------------------
-
-// ListenConfirm opens a direct NATS connection and subscribes to the hardcoded
-// "confirm_booking" and "confirm_purchase" subjects. It reconnects automatically
-// if the connection is lost.
-func ListenConfirm() {
-	natsURL := config.GetConfig().NATSUrl
-	if natsURL == "" {
-		fmt.Println("ListenConfirm: NATS_SERVER not set, skipping confirm listeners")
-		return
-	}
-	for {
-		nc, err := nats.Connect(natsURL)
-		if err != nil {
-			fmt.Println("ListenConfirm: could not connect to NATS:", err)
-			time.Sleep(time.Minute)
-			continue
-		}
-		var wg sync.WaitGroup
-		wg.Add(2)
-		go listenConfirmChannel(nc, "confirm_booking", tools.BOOKING, &wg)
-		go listenConfirmChannel(nc, "confirm_purchase", tools.PURCHASE_RESOURCE, &wg)
-		wg.Wait()
-		nc.Close()
-	}
-}
-
 // ---------------------------------------------------------------------------
 // Draft timeout
 // ---------------------------------------------------------------------------

infrastructure/nats_handlers.go

@@ -3,7 +3,6 @@ package infrastructure
 import (
 	"encoding/json"
 	"fmt"
-	"sync"
 	"time"
 
 	oclib "cloud.o-forge.io/core/oc-lib"
@@ -15,9 +14,12 @@ import (
 	"cloud.o-forge.io/core/oc-lib/models/utils"
 	"cloud.o-forge.io/core/oc-lib/models/workflow"
 	"cloud.o-forge.io/core/oc-lib/tools"
-	"github.com/nats-io/nats.go"
 )
 
+func handleConfirm(resp tools.NATSResponse) {
+	confirmResource(string(resp.Payload), resp.Datatype)
+}
+
 func handlePlannerExecution(resp tools.NATSResponse) {
 	m := map[string]interface{}{}
 	p := planner.Planner{}
@@ -255,20 +257,3 @@ func confirmResource(id string, dt tools.DataType) {
 		}
 	}
 }
-
-// listenConfirmChannel subscribes to a NATS subject and calls confirmResource
-// for each message received. The message body is expected to be the plain
-// resource ID (UTF-8 string).
-func listenConfirmChannel(nc *nats.Conn, subject string, dt tools.DataType, wg *sync.WaitGroup) {
-	defer wg.Done()
-	ch := make(chan *nats.Msg, 64)
-	sub, err := nc.ChanSubscribe(subject, ch)
-	if err != nil {
-		fmt.Printf("listenConfirmChannel: could not subscribe to %s: %v\n", subject, err)
-		return
-	}
-	defer sub.Unsubscribe()
-	for msg := range ch {
-		confirmResource(string(msg.Data), dt)
-	}
-}

infrastructure/scheduler.go

@@ -52,20 +52,6 @@ type WorkflowSchedule struct {
 	Confirm bool `json:"confirm,omitempty"`
 }
 
-// TODO PREEMPTION !
-/*
-To schedule a preempted, omg.
-pour faire ça on doit alors lancé une exécution prioritaire qui passera devant toutes les autres, celon un niveau de priorité.
-Preemptible = 7, pour le moment il n'existera que 0 et 7.
-Dans le cas d'une préemption l'exécution est immédiable et bloquera tout le monde tant qu'il n'a pas été exécuté.
-Une ressource doit pouvoir être preemptible pour être exécutée de la sorte.
-Se qui implique si on est sur une ressource par ressource que si un élement n'est pas préemptible,
-alors il devra être effectué dés que possible
-
-Dans le cas dés que possible, la start date est immédiate MAIS !
-ne pourra se lancé que SI il n'existe pas d'exécution se lançant durant la période indicative. ( Ultra complexe )
-*/
-
 func NewScheduler(mode int, start string, end string, durationInS float64, cron string) *WorkflowSchedule {
 	ws := &WorkflowSchedule{
 		UUID:        uuid.New().String(),
@@ -246,14 +232,6 @@ func propagateResource(obj utils.DBObject, destPeerID string, dt tools.DataType,
 	errCh <- nil
 }
 
-/*
-BOOKING IMPLIED TIME, not of subscription but of execution
-so is processing time execution time applied on computes
-data can improve the processing time
-time should implied a security time border (10sec) if not from the same executions
-VERIFY THAT WE HANDLE DIFFERENCE BETWEEN LOCATION TIME && BOOKING
-*/
-
 /*
 * getExecutions is a function that returns the executions of a workflow
 * it returns an array of workflow_execution.WorkflowExecution